#pragma once

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

// Package: Phoenix

#include "Basic.hpp"

#include "DialoguePlugin_structs.hpp"
#include "Phoenix_structs.hpp"
#include "GameplayTags_structs.hpp"
#include "GameplayAbilities_structs.hpp"
#include "CoreUObject_structs.hpp"
#include "PhysicsCore_structs.hpp"
#include "Engine_structs.hpp"
#include "AkAudio_structs.hpp"
#include "AIModule_structs.hpp"
#include "UMG_structs.hpp"
#include "MovieScene_structs.hpp"
#include "InputCore_structs.hpp"
#include "SDSOnline_structs.hpp"


namespace SDK::Params
{

// Function Phoenix.State.AddAllChildStates
// 0x0010 (0x0010 - 0x0000)
struct State_AddAllChildStates final
{
public:
	struct FStateRef                              DefaultState;                                      // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_AddAllChildStates) == 0x000008, "Wrong alignment on State_AddAllChildStates");
static_assert(sizeof(State_AddAllChildStates) == 0x000010, "Wrong size on State_AddAllChildStates");
static_assert(offsetof(State_AddAllChildStates, DefaultState) == 0x000000, "Member 'State_AddAllChildStates::DefaultState' has a wrong offset!");

// Function Phoenix.State.AddChildState
// 0x0020 (0x0020 - 0x0000)
struct State_AddChildState final
{
public:
	TSubclassOf<class UState>                     StateClass;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ID;                                                // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         EnumId;                                            // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UState*                                 ReturnValue;                                       // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_AddChildState) == 0x000008, "Wrong alignment on State_AddChildState");
static_assert(sizeof(State_AddChildState) == 0x000020, "Wrong size on State_AddChildState");
static_assert(offsetof(State_AddChildState, StateClass) == 0x000000, "Member 'State_AddChildState::StateClass' has a wrong offset!");
static_assert(offsetof(State_AddChildState, ID) == 0x000008, "Member 'State_AddChildState::ID' has a wrong offset!");
static_assert(offsetof(State_AddChildState, EnumId) == 0x000010, "Member 'State_AddChildState::EnumId' has a wrong offset!");
static_assert(offsetof(State_AddChildState, ReturnValue) == 0x000018, "Member 'State_AddChildState::ReturnValue' has a wrong offset!");

// Function Phoenix.State.AddChildStateRef
// 0x0020 (0x0020 - 0x0000)
struct State_AddChildStateRef final
{
public:
	struct FStateRef                              StateRef;                                          // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         EnumId;                                            // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UState*                                 ReturnValue;                                       // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_AddChildStateRef) == 0x000008, "Wrong alignment on State_AddChildStateRef");
static_assert(sizeof(State_AddChildStateRef) == 0x000020, "Wrong size on State_AddChildStateRef");
static_assert(offsetof(State_AddChildStateRef, StateRef) == 0x000000, "Member 'State_AddChildStateRef::StateRef' has a wrong offset!");
static_assert(offsetof(State_AddChildStateRef, EnumId) == 0x000010, "Member 'State_AddChildStateRef::EnumId' has a wrong offset!");
static_assert(offsetof(State_AddChildStateRef, ReturnValue) == 0x000018, "Member 'State_AddChildStateRef::ReturnValue' has a wrong offset!");

// Function Phoenix.State.AddSiblingState
// 0x0018 (0x0018 - 0x0000)
struct State_AddSiblingState final
{
public:
	TSubclassOf<class UState>                     StateClass;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ID;                                                // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UState*                                 ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_AddSiblingState) == 0x000008, "Wrong alignment on State_AddSiblingState");
static_assert(sizeof(State_AddSiblingState) == 0x000018, "Wrong size on State_AddSiblingState");
static_assert(offsetof(State_AddSiblingState, StateClass) == 0x000000, "Member 'State_AddSiblingState::StateClass' has a wrong offset!");
static_assert(offsetof(State_AddSiblingState, ID) == 0x000008, "Member 'State_AddSiblingState::ID' has a wrong offset!");
static_assert(offsetof(State_AddSiblingState, ReturnValue) == 0x000010, "Member 'State_AddSiblingState::ReturnValue' has a wrong offset!");

// Function Phoenix.State.AddSiblingStateRef
// 0x0018 (0x0018 - 0x0000)
struct State_AddSiblingStateRef final
{
public:
	struct FStateRef                              StateRef;                                          // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	class UState*                                 ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_AddSiblingStateRef) == 0x000008, "Wrong alignment on State_AddSiblingStateRef");
static_assert(sizeof(State_AddSiblingStateRef) == 0x000018, "Wrong size on State_AddSiblingStateRef");
static_assert(offsetof(State_AddSiblingStateRef, StateRef) == 0x000000, "Member 'State_AddSiblingStateRef::StateRef' has a wrong offset!");
static_assert(offsetof(State_AddSiblingStateRef, ReturnValue) == 0x000010, "Member 'State_AddSiblingStateRef::ReturnValue' has a wrong offset!");

// Function Phoenix.State.Begin
// 0x0008 (0x0008 - 0x0000)
struct State_Begin final
{
public:
	const class UStateParams*                     Params_0;                                          // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_Begin) == 0x000008, "Wrong alignment on State_Begin");
static_assert(sizeof(State_Begin) == 0x000008, "Wrong size on State_Begin");
static_assert(offsetof(State_Begin, Params_0) == 0x000000, "Member 'State_Begin::Params_0' has a wrong offset!");

// Function Phoenix.State.BeginChild
// 0x0008 (0x0008 - 0x0000)
struct State_BeginChild final
{
public:
	const class UStateParams*                     Params_0;                                          // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_BeginChild) == 0x000008, "Wrong alignment on State_BeginChild");
static_assert(sizeof(State_BeginChild) == 0x000008, "Wrong size on State_BeginChild");
static_assert(offsetof(State_BeginChild, Params_0) == 0x000000, "Member 'State_BeginChild::Params_0' has a wrong offset!");

// Function Phoenix.State.GetDebugDisplayText
// 0x0018 (0x0018 - 0x0000)
struct State_GetDebugDisplayText final
{
public:
	class FText                                   ReturnValue;                                       // 0x0000(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_GetDebugDisplayText) == 0x000008, "Wrong alignment on State_GetDebugDisplayText");
static_assert(sizeof(State_GetDebugDisplayText) == 0x000018, "Wrong size on State_GetDebugDisplayText");
static_assert(offsetof(State_GetDebugDisplayText, ReturnValue) == 0x000000, "Member 'State_GetDebugDisplayText::ReturnValue' has a wrong offset!");

// Function Phoenix.State.Init
// 0x0018 (0x0018 - 0x0000)
struct State_Init final
{
public:
	class UObject*                                OwnerParam;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UState*                                 ParentState;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ID;                                                // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_Init) == 0x000008, "Wrong alignment on State_Init");
static_assert(sizeof(State_Init) == 0x000018, "Wrong size on State_Init");
static_assert(offsetof(State_Init, OwnerParam) == 0x000000, "Member 'State_Init::OwnerParam' has a wrong offset!");
static_assert(offsetof(State_Init, ParentState) == 0x000008, "Member 'State_Init::ParentState' has a wrong offset!");
static_assert(offsetof(State_Init, ID) == 0x000010, "Member 'State_Init::ID' has a wrong offset!");

// Function Phoenix.State.IsSelfFinished
// 0x0001 (0x0001 - 0x0000)
struct State_IsSelfFinished final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_IsSelfFinished) == 0x000001, "Wrong alignment on State_IsSelfFinished");
static_assert(sizeof(State_IsSelfFinished) == 0x000001, "Wrong size on State_IsSelfFinished");
static_assert(offsetof(State_IsSelfFinished, ReturnValue) == 0x000000, "Member 'State_IsSelfFinished::ReturnValue' has a wrong offset!");

// Function Phoenix.State.IsStateFinished
// 0x0001 (0x0001 - 0x0000)
struct State_IsStateFinished final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_IsStateFinished) == 0x000001, "Wrong alignment on State_IsStateFinished");
static_assert(sizeof(State_IsStateFinished) == 0x000001, "Wrong size on State_IsStateFinished");
static_assert(offsetof(State_IsStateFinished, ReturnValue) == 0x000000, "Member 'State_IsStateFinished::ReturnValue' has a wrong offset!");

// Function Phoenix.State.OnBegin
// 0x0008 (0x0008 - 0x0000)
struct State_OnBegin final
{
public:
	const class UStateParams*                     Params_0;                                          // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_OnBegin) == 0x000008, "Wrong alignment on State_OnBegin");
static_assert(sizeof(State_OnBegin) == 0x000008, "Wrong size on State_OnBegin");
static_assert(offsetof(State_OnBegin, Params_0) == 0x000000, "Member 'State_OnBegin::Params_0' has a wrong offset!");

// Function Phoenix.State.OnStateChange
// 0x0010 (0x0010 - 0x0000)
struct State_OnStateChange final
{
public:
	class FName                                   OldStateID;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   NewStateID;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_OnStateChange) == 0x000004, "Wrong alignment on State_OnStateChange");
static_assert(sizeof(State_OnStateChange) == 0x000010, "Wrong size on State_OnStateChange");
static_assert(offsetof(State_OnStateChange, OldStateID) == 0x000000, "Member 'State_OnStateChange::OldStateID' has a wrong offset!");
static_assert(offsetof(State_OnStateChange, NewStateID) == 0x000008, "Member 'State_OnStateChange::NewStateID' has a wrong offset!");

// Function Phoenix.State.OnTick
// 0x0004 (0x0004 - 0x0000)
struct State_OnTick final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_OnTick) == 0x000004, "Wrong alignment on State_OnTick");
static_assert(sizeof(State_OnTick) == 0x000004, "Wrong size on State_OnTick");
static_assert(offsetof(State_OnTick, DeltaTime) == 0x000000, "Member 'State_OnTick::DeltaTime' has a wrong offset!");

// Function Phoenix.State.RefreshInputs
// 0x0004 (0x0004 - 0x0000)
struct State_RefreshInputs final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_RefreshInputs) == 0x000004, "Wrong alignment on State_RefreshInputs");
static_assert(sizeof(State_RefreshInputs) == 0x000004, "Wrong size on State_RefreshInputs");
static_assert(offsetof(State_RefreshInputs, DeltaTime) == 0x000000, "Member 'State_RefreshInputs::DeltaTime' has a wrong offset!");

// Function Phoenix.State.RemoveChildState
// 0x0010 (0x0010 - 0x0000)
struct State_RemoveChildState final
{
public:
	struct FStateRef                              StateRef;                                          // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_RemoveChildState) == 0x000008, "Wrong alignment on State_RemoveChildState");
static_assert(sizeof(State_RemoveChildState) == 0x000010, "Wrong size on State_RemoveChildState");
static_assert(offsetof(State_RemoveChildState, StateRef) == 0x000000, "Member 'State_RemoveChildState::StateRef' has a wrong offset!");

// Function Phoenix.State.ShouldWaitForChildToFinish
// 0x0001 (0x0001 - 0x0000)
struct State_ShouldWaitForChildToFinish final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_ShouldWaitForChildToFinish) == 0x000001, "Wrong alignment on State_ShouldWaitForChildToFinish");
static_assert(sizeof(State_ShouldWaitForChildToFinish) == 0x000001, "Wrong size on State_ShouldWaitForChildToFinish");
static_assert(offsetof(State_ShouldWaitForChildToFinish, ReturnValue) == 0x000000, "Member 'State_ShouldWaitForChildToFinish::ReturnValue' has a wrong offset!");

// Function Phoenix.State.Tick
// 0x0004 (0x0004 - 0x0000)
struct State_Tick final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_Tick) == 0x000004, "Wrong alignment on State_Tick");
static_assert(sizeof(State_Tick) == 0x000004, "Wrong size on State_Tick");
static_assert(offsetof(State_Tick, DeltaTime) == 0x000000, "Member 'State_Tick::DeltaTime' has a wrong offset!");

// Function Phoenix.State.GetActiveChild
// 0x0008 (0x0008 - 0x0000)
struct State_GetActiveChild final
{
public:
	class UState*                                 ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_GetActiveChild) == 0x000008, "Wrong alignment on State_GetActiveChild");
static_assert(sizeof(State_GetActiveChild) == 0x000008, "Wrong size on State_GetActiveChild");
static_assert(offsetof(State_GetActiveChild, ReturnValue) == 0x000000, "Member 'State_GetActiveChild::ReturnValue' has a wrong offset!");

// Function Phoenix.State.GetDeepestTimeActive
// 0x0004 (0x0004 - 0x0000)
struct State_GetDeepestTimeActive final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_GetDeepestTimeActive) == 0x000004, "Wrong alignment on State_GetDeepestTimeActive");
static_assert(sizeof(State_GetDeepestTimeActive) == 0x000004, "Wrong size on State_GetDeepestTimeActive");
static_assert(offsetof(State_GetDeepestTimeActive, ReturnValue) == 0x000000, "Member 'State_GetDeepestTimeActive::ReturnValue' has a wrong offset!");

// Function Phoenix.State.GetStateID
// 0x0008 (0x0008 - 0x0000)
struct State_GetStateID final
{
public:
	class FName                                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_GetStateID) == 0x000004, "Wrong alignment on State_GetStateID");
static_assert(sizeof(State_GetStateID) == 0x000008, "Wrong size on State_GetStateID");
static_assert(offsetof(State_GetStateID, ReturnValue) == 0x000000, "Member 'State_GetStateID::ReturnValue' has a wrong offset!");

// Function Phoenix.State.GetTimeActive
// 0x0004 (0x0004 - 0x0000)
struct State_GetTimeActive final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_GetTimeActive) == 0x000004, "Wrong alignment on State_GetTimeActive");
static_assert(sizeof(State_GetTimeActive) == 0x000004, "Wrong size on State_GetTimeActive");
static_assert(offsetof(State_GetTimeActive, ReturnValue) == 0x000000, "Member 'State_GetTimeActive::ReturnValue' has a wrong offset!");

// Function Phoenix.State.IsActive
// 0x0001 (0x0001 - 0x0000)
struct State_IsActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_IsActive) == 0x000001, "Wrong alignment on State_IsActive");
static_assert(sizeof(State_IsActive) == 0x000001, "Wrong size on State_IsActive");
static_assert(offsetof(State_IsActive, ReturnValue) == 0x000000, "Member 'State_IsActive::ReturnValue' has a wrong offset!");

// Function Phoenix.State.IsSelfFinisher
// 0x0001 (0x0001 - 0x0000)
struct State_IsSelfFinisher final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(State_IsSelfFinisher) == 0x000001, "Wrong alignment on State_IsSelfFinisher");
static_assert(sizeof(State_IsSelfFinisher) == 0x000001, "Wrong size on State_IsSelfFinisher");
static_assert(offsetof(State_IsSelfFinisher, ReturnValue) == 0x000000, "Member 'State_IsSelfFinisher::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAnimNotify.GetSourceObject
// 0x0008 (0x0008 - 0x0000)
struct PhxAnimNotify_GetSourceObject final
{
public:
	class UObject*                                ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAnimNotify_GetSourceObject) == 0x000008, "Wrong alignment on PhxAnimNotify_GetSourceObject");
static_assert(sizeof(PhxAnimNotify_GetSourceObject) == 0x000008, "Wrong size on PhxAnimNotify_GetSourceObject");
static_assert(offsetof(PhxAnimNotify_GetSourceObject, ReturnValue) == 0x000000, "Member 'PhxAnimNotify_GetSourceObject::ReturnValue' has a wrong offset!");

// Function Phoenix.CharacterState.OnNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct CharacterState_OnNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CharacterState_OnNotifyReceived) == 0x000008, "Wrong alignment on CharacterState_OnNotifyReceived");
static_assert(sizeof(CharacterState_OnNotifyReceived) == 0x000008, "Wrong size on CharacterState_OnNotifyReceived");
static_assert(offsetof(CharacterState_OnNotifyReceived, Notify) == 0x000000, "Member 'CharacterState_OnNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.CharacterState.OnNotifyStateBeginReceived
// 0x0010 (0x0010 - 0x0000)
struct CharacterState_OnNotifyStateBeginReceived final
{
public:
	const class UPhxAnimNotifyState*              NotifyState;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequenceBase*                      Animation;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CharacterState_OnNotifyStateBeginReceived) == 0x000008, "Wrong alignment on CharacterState_OnNotifyStateBeginReceived");
static_assert(sizeof(CharacterState_OnNotifyStateBeginReceived) == 0x000010, "Wrong size on CharacterState_OnNotifyStateBeginReceived");
static_assert(offsetof(CharacterState_OnNotifyStateBeginReceived, NotifyState) == 0x000000, "Member 'CharacterState_OnNotifyStateBeginReceived::NotifyState' has a wrong offset!");
static_assert(offsetof(CharacterState_OnNotifyStateBeginReceived, Animation) == 0x000008, "Member 'CharacterState_OnNotifyStateBeginReceived::Animation' has a wrong offset!");

// Function Phoenix.CharacterState.OnNotifyStateEndReceived
// 0x0010 (0x0010 - 0x0000)
struct CharacterState_OnNotifyStateEndReceived final
{
public:
	const class UPhxAnimNotifyState*              NotifyState;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequenceBase*                      Animation;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CharacterState_OnNotifyStateEndReceived) == 0x000008, "Wrong alignment on CharacterState_OnNotifyStateEndReceived");
static_assert(sizeof(CharacterState_OnNotifyStateEndReceived) == 0x000010, "Wrong size on CharacterState_OnNotifyStateEndReceived");
static_assert(offsetof(CharacterState_OnNotifyStateEndReceived, NotifyState) == 0x000000, "Member 'CharacterState_OnNotifyStateEndReceived::NotifyState' has a wrong offset!");
static_assert(offsetof(CharacterState_OnNotifyStateEndReceived, Animation) == 0x000008, "Member 'CharacterState_OnNotifyStateEndReceived::Animation' has a wrong offset!");

// Function Phoenix.CharacterState.GetCharacter
// 0x0008 (0x0008 - 0x0000)
struct CharacterState_GetCharacter final
{
public:
	class APhxCharacter*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CharacterState_GetCharacter) == 0x000008, "Wrong alignment on CharacterState_GetCharacter");
static_assert(sizeof(CharacterState_GetCharacter) == 0x000008, "Wrong size on CharacterState_GetCharacter");
static_assert(offsetof(CharacterState_GetCharacter, ReturnValue) == 0x000000, "Member 'CharacterState_GetCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.Gadget.GetInteractableComp
// 0x0008 (0x0008 - 0x0000)
struct Gadget_GetInteractableComp final
{
public:
	class UInteractableComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Gadget_GetInteractableComp) == 0x000008, "Wrong alignment on Gadget_GetInteractableComp");
static_assert(sizeof(Gadget_GetInteractableComp) == 0x000008, "Wrong size on Gadget_GetInteractableComp");
static_assert(offsetof(Gadget_GetInteractableComp, ReturnValue) == 0x000000, "Member 'Gadget_GetInteractableComp::ReturnValue' has a wrong offset!");

// Function Phoenix.Gadget.HandleProximityChanged
// 0x0002 (0x0002 - 0x0000)
struct Gadget_HandleProximityChanged final
{
public:
	EInteractableProximity                        Promity;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInteractableProximity                        PreviousProximity;                                 // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Gadget_HandleProximityChanged) == 0x000001, "Wrong alignment on Gadget_HandleProximityChanged");
static_assert(sizeof(Gadget_HandleProximityChanged) == 0x000002, "Wrong size on Gadget_HandleProximityChanged");
static_assert(offsetof(Gadget_HandleProximityChanged, Promity) == 0x000000, "Member 'Gadget_HandleProximityChanged::Promity' has a wrong offset!");
static_assert(offsetof(Gadget_HandleProximityChanged, PreviousProximity) == 0x000001, "Member 'Gadget_HandleProximityChanged::PreviousProximity' has a wrong offset!");

// Function Phoenix.Gadget.NotifyProximityChanged
// 0x0002 (0x0002 - 0x0000)
struct Gadget_NotifyProximityChanged final
{
public:
	EInteractableProximity                        Promity;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInteractableProximity                        PreviousProximity;                                 // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Gadget_NotifyProximityChanged) == 0x000001, "Wrong alignment on Gadget_NotifyProximityChanged");
static_assert(sizeof(Gadget_NotifyProximityChanged) == 0x000002, "Wrong size on Gadget_NotifyProximityChanged");
static_assert(offsetof(Gadget_NotifyProximityChanged, Promity) == 0x000000, "Member 'Gadget_NotifyProximityChanged::Promity' has a wrong offset!");
static_assert(offsetof(Gadget_NotifyProximityChanged, PreviousProximity) == 0x000001, "Member 'Gadget_NotifyProximityChanged::PreviousProximity' has a wrong offset!");

// Function Phoenix.Gadget.GetEnterAnim
// 0x0008 (0x0008 - 0x0000)
struct Gadget_GetEnterAnim final
{
public:
	class UAnimMontage*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Gadget_GetEnterAnim) == 0x000008, "Wrong alignment on Gadget_GetEnterAnim");
static_assert(sizeof(Gadget_GetEnterAnim) == 0x000008, "Wrong size on Gadget_GetEnterAnim");
static_assert(offsetof(Gadget_GetEnterAnim, ReturnValue) == 0x000000, "Member 'Gadget_GetEnterAnim::ReturnValue' has a wrong offset!");

// Function Phoenix.Gadget.GetExitAnim
// 0x0008 (0x0008 - 0x0000)
struct Gadget_GetExitAnim final
{
public:
	class UAnimMontage*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Gadget_GetExitAnim) == 0x000008, "Wrong alignment on Gadget_GetExitAnim");
static_assert(sizeof(Gadget_GetExitAnim) == 0x000008, "Wrong size on Gadget_GetExitAnim");
static_assert(offsetof(Gadget_GetExitAnim, ReturnValue) == 0x000000, "Member 'Gadget_GetExitAnim::ReturnValue' has a wrong offset!");

// Function Phoenix.Gadget.GetIdleAnim
// 0x0008 (0x0008 - 0x0000)
struct Gadget_GetIdleAnim final
{
public:
	class UAnimMontage*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Gadget_GetIdleAnim) == 0x000008, "Wrong alignment on Gadget_GetIdleAnim");
static_assert(sizeof(Gadget_GetIdleAnim) == 0x000008, "Wrong size on Gadget_GetIdleAnim");
static_assert(offsetof(Gadget_GetIdleAnim, ReturnValue) == 0x000000, "Member 'Gadget_GetIdleAnim::ReturnValue' has a wrong offset!");

// Function Phoenix.Gadget.GetUserCharacter
// 0x0008 (0x0008 - 0x0000)
struct Gadget_GetUserCharacter final
{
public:
	class APhxCharacter*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Gadget_GetUserCharacter) == 0x000008, "Wrong alignment on Gadget_GetUserCharacter");
static_assert(sizeof(Gadget_GetUserCharacter) == 0x000008, "Wrong size on Gadget_GetUserCharacter");
static_assert(offsetof(Gadget_GetUserCharacter, ReturnValue) == 0x000000, "Member 'Gadget_GetUserCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.MicroSwitchboardPuzzle.CheckForPuzzleSuccess
// 0x0001 (0x0001 - 0x0000)
struct MicroSwitchboardPuzzle_CheckForPuzzleSuccess final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MicroSwitchboardPuzzle_CheckForPuzzleSuccess) == 0x000001, "Wrong alignment on MicroSwitchboardPuzzle_CheckForPuzzleSuccess");
static_assert(sizeof(MicroSwitchboardPuzzle_CheckForPuzzleSuccess) == 0x000001, "Wrong size on MicroSwitchboardPuzzle_CheckForPuzzleSuccess");
static_assert(offsetof(MicroSwitchboardPuzzle_CheckForPuzzleSuccess, ReturnValue) == 0x000000, "Member 'MicroSwitchboardPuzzle_CheckForPuzzleSuccess::ReturnValue' has a wrong offset!");

// Function Phoenix.MicroSwitchboardPuzzle.LeverPulled
// 0x0008 (0x0008 - 0x0000)
struct MicroSwitchboardPuzzle_LeverPulled final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MicroSwitchboardPuzzle_LeverPulled) == 0x000008, "Wrong alignment on MicroSwitchboardPuzzle_LeverPulled");
static_assert(sizeof(MicroSwitchboardPuzzle_LeverPulled) == 0x000008, "Wrong size on MicroSwitchboardPuzzle_LeverPulled");
static_assert(offsetof(MicroSwitchboardPuzzle_LeverPulled, InteractedBy) == 0x000000, "Member 'MicroSwitchboardPuzzle_LeverPulled::InteractedBy' has a wrong offset!");

// Function Phoenix.MicroSwitchboardPuzzle.OnAttemptPowerOn
// 0x0001 (0x0001 - 0x0000)
struct MicroSwitchboardPuzzle_OnAttemptPowerOn final
{
public:
	bool                                          bWithCorrectSolution;                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MicroSwitchboardPuzzle_OnAttemptPowerOn) == 0x000001, "Wrong alignment on MicroSwitchboardPuzzle_OnAttemptPowerOn");
static_assert(sizeof(MicroSwitchboardPuzzle_OnAttemptPowerOn) == 0x000001, "Wrong size on MicroSwitchboardPuzzle_OnAttemptPowerOn");
static_assert(offsetof(MicroSwitchboardPuzzle_OnAttemptPowerOn, bWithCorrectSolution) == 0x000000, "Member 'MicroSwitchboardPuzzle_OnAttemptPowerOn::bWithCorrectSolution' has a wrong offset!");

// Function Phoenix.MicroSwitchboardPuzzle.IsPuzzleSolved
// 0x0001 (0x0001 - 0x0000)
struct MicroSwitchboardPuzzle_IsPuzzleSolved final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MicroSwitchboardPuzzle_IsPuzzleSolved) == 0x000001, "Wrong alignment on MicroSwitchboardPuzzle_IsPuzzleSolved");
static_assert(sizeof(MicroSwitchboardPuzzle_IsPuzzleSolved) == 0x000001, "Wrong size on MicroSwitchboardPuzzle_IsPuzzleSolved");
static_assert(offsetof(MicroSwitchboardPuzzle_IsPuzzleSolved, ReturnValue) == 0x000000, "Member 'MicroSwitchboardPuzzle_IsPuzzleSolved::ReturnValue' has a wrong offset!");

// Function Phoenix.AbilityHitReactState.OnAbilityFinished
// 0x000C (0x000C - 0x0000)
struct AbilityHitReactState_OnAbilityFinished final
{
public:
	struct FGameplayTag                           InTag;                                             // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NewCount;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AbilityHitReactState_OnAbilityFinished) == 0x000004, "Wrong alignment on AbilityHitReactState_OnAbilityFinished");
static_assert(sizeof(AbilityHitReactState_OnAbilityFinished) == 0x00000C, "Wrong size on AbilityHitReactState_OnAbilityFinished");
static_assert(offsetof(AbilityHitReactState_OnAbilityFinished, InTag) == 0x000000, "Member 'AbilityHitReactState_OnAbilityFinished::InTag' has a wrong offset!");
static_assert(offsetof(AbilityHitReactState_OnAbilityFinished, NewCount) == 0x000008, "Member 'AbilityHitReactState_OnAbilityFinished::NewCount' has a wrong offset!");

// Function Phoenix.PhxSelectable.LocalizeDate
// 0x0020 (0x0020 - 0x0000)
struct PhxSelectable_LocalizeDate final
{
public:
	struct FDateTime                              InDateTime;                                        // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FText                                   ReturnValue;                                       // 0x0008(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_LocalizeDate) == 0x000008, "Wrong alignment on PhxSelectable_LocalizeDate");
static_assert(sizeof(PhxSelectable_LocalizeDate) == 0x000020, "Wrong size on PhxSelectable_LocalizeDate");
static_assert(offsetof(PhxSelectable_LocalizeDate, InDateTime) == 0x000000, "Member 'PhxSelectable_LocalizeDate::InDateTime' has a wrong offset!");
static_assert(offsetof(PhxSelectable_LocalizeDate, ReturnValue) == 0x000008, "Member 'PhxSelectable_LocalizeDate::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSelectable.SetDisabled
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_SetDisabled final
{
public:
	bool                                          bIsDisabled;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_SetDisabled) == 0x000001, "Wrong alignment on PhxSelectable_SetDisabled");
static_assert(sizeof(PhxSelectable_SetDisabled) == 0x000001, "Wrong size on PhxSelectable_SetDisabled");
static_assert(offsetof(PhxSelectable_SetDisabled, bIsDisabled) == 0x000000, "Member 'PhxSelectable_SetDisabled::bIsDisabled' has a wrong offset!");

// Function Phoenix.PhxSelectable.SetFocused
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_SetFocused final
{
public:
	bool                                          bFocused;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_SetFocused) == 0x000001, "Wrong alignment on PhxSelectable_SetFocused");
static_assert(sizeof(PhxSelectable_SetFocused) == 0x000001, "Wrong size on PhxSelectable_SetFocused");
static_assert(offsetof(PhxSelectable_SetFocused, bFocused) == 0x000000, "Member 'PhxSelectable_SetFocused::bFocused' has a wrong offset!");

// Function Phoenix.PhxSelectable.SetLocked
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_SetLocked final
{
public:
	bool                                          bLocked;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_SetLocked) == 0x000001, "Wrong alignment on PhxSelectable_SetLocked");
static_assert(sizeof(PhxSelectable_SetLocked) == 0x000001, "Wrong size on PhxSelectable_SetLocked");
static_assert(offsetof(PhxSelectable_SetLocked, bLocked) == 0x000000, "Member 'PhxSelectable_SetLocked::bLocked' has a wrong offset!");

// Function Phoenix.PhxSelectable.SetNotificationOn
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_SetNotificationOn final
{
public:
	bool                                          bIsOn;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_SetNotificationOn) == 0x000001, "Wrong alignment on PhxSelectable_SetNotificationOn");
static_assert(sizeof(PhxSelectable_SetNotificationOn) == 0x000001, "Wrong size on PhxSelectable_SetNotificationOn");
static_assert(offsetof(PhxSelectable_SetNotificationOn, bIsOn) == 0x000000, "Member 'PhxSelectable_SetNotificationOn::bIsOn' has a wrong offset!");

// Function Phoenix.PhxSelectable.SetSelected
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_SetSelected final
{
public:
	bool                                          bSelected;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_SetSelected) == 0x000001, "Wrong alignment on PhxSelectable_SetSelected");
static_assert(sizeof(PhxSelectable_SetSelected) == 0x000001, "Wrong size on PhxSelectable_SetSelected");
static_assert(offsetof(PhxSelectable_SetSelected, bSelected) == 0x000000, "Member 'PhxSelectable_SetSelected::bSelected' has a wrong offset!");

// Function Phoenix.PhxSelectable.GetMenuReaderTag
// 0x0008 (0x0008 - 0x0000)
struct PhxSelectable_GetMenuReaderTag final
{
public:
	class FName                                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_GetMenuReaderTag) == 0x000004, "Wrong alignment on PhxSelectable_GetMenuReaderTag");
static_assert(sizeof(PhxSelectable_GetMenuReaderTag) == 0x000008, "Wrong size on PhxSelectable_GetMenuReaderTag");
static_assert(offsetof(PhxSelectable_GetMenuReaderTag, ReturnValue) == 0x000000, "Member 'PhxSelectable_GetMenuReaderTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSelectable.IsFocused
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_IsFocused final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_IsFocused) == 0x000001, "Wrong alignment on PhxSelectable_IsFocused");
static_assert(sizeof(PhxSelectable_IsFocused) == 0x000001, "Wrong size on PhxSelectable_IsFocused");
static_assert(offsetof(PhxSelectable_IsFocused, ReturnValue) == 0x000000, "Member 'PhxSelectable_IsFocused::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSelectable.IsLocked
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_IsLocked final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_IsLocked) == 0x000001, "Wrong alignment on PhxSelectable_IsLocked");
static_assert(sizeof(PhxSelectable_IsLocked) == 0x000001, "Wrong size on PhxSelectable_IsLocked");
static_assert(offsetof(PhxSelectable_IsLocked, ReturnValue) == 0x000000, "Member 'PhxSelectable_IsLocked::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSelectable.IsNotificationOn
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_IsNotificationOn final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_IsNotificationOn) == 0x000001, "Wrong alignment on PhxSelectable_IsNotificationOn");
static_assert(sizeof(PhxSelectable_IsNotificationOn) == 0x000001, "Wrong size on PhxSelectable_IsNotificationOn");
static_assert(offsetof(PhxSelectable_IsNotificationOn, ReturnValue) == 0x000000, "Member 'PhxSelectable_IsNotificationOn::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSelectable.IsOptionDisabled
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_IsOptionDisabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_IsOptionDisabled) == 0x000001, "Wrong alignment on PhxSelectable_IsOptionDisabled");
static_assert(sizeof(PhxSelectable_IsOptionDisabled) == 0x000001, "Wrong size on PhxSelectable_IsOptionDisabled");
static_assert(offsetof(PhxSelectable_IsOptionDisabled, ReturnValue) == 0x000000, "Member 'PhxSelectable_IsOptionDisabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSelectable.IsSelected
// 0x0001 (0x0001 - 0x0000)
struct PhxSelectable_IsSelected final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSelectable_IsSelected) == 0x000001, "Wrong alignment on PhxSelectable_IsSelected");
static_assert(sizeof(PhxSelectable_IsSelected) == 0x000001, "Wrong size on PhxSelectable_IsSelected");
static_assert(offsetof(PhxSelectable_IsSelected, ReturnValue) == 0x000000, "Member 'PhxSelectable_IsSelected::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxBiosSlot.SetFullBio
// 0x0008 (0x0008 - 0x0000)
struct PhxBiosSlot_SetFullBio final
{
public:
	const class UBiosVirtualData*                 BioVID;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBiosSlot_SetFullBio) == 0x000008, "Wrong alignment on PhxBiosSlot_SetFullBio");
static_assert(sizeof(PhxBiosSlot_SetFullBio) == 0x000008, "Wrong size on PhxBiosSlot_SetFullBio");
static_assert(offsetof(PhxBiosSlot_SetFullBio, BioVID) == 0x000000, "Member 'PhxBiosSlot_SetFullBio::BioVID' has a wrong offset!");

// Function Phoenix.PhxBiosSlot.SetPartialBio
// 0x0008 (0x0008 - 0x0000)
struct PhxBiosSlot_SetPartialBio final
{
public:
	const class UBiosVirtualData*                 BioVID;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBiosSlot_SetPartialBio) == 0x000008, "Wrong alignment on PhxBiosSlot_SetPartialBio");
static_assert(sizeof(PhxBiosSlot_SetPartialBio) == 0x000008, "Wrong size on PhxBiosSlot_SetPartialBio");
static_assert(offsetof(PhxBiosSlot_SetPartialBio, BioVID) == 0x000000, "Member 'PhxBiosSlot_SetPartialBio::BioVID' has a wrong offset!");

// Function Phoenix.PhxBlueprintAction_PlayScriptedEvent.PlayScriptedEvent
// 0x0010 (0x0010 - 0x0000)
struct PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent final
{
public:
	class APhxScriptedEventActor*                 ScriptedEventActor;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxBlueprintAction_PlayScriptedEvent*  ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent) == 0x000008, "Wrong alignment on PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent");
static_assert(sizeof(PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent) == 0x000010, "Wrong size on PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent");
static_assert(offsetof(PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent, ScriptedEventActor) == 0x000000, "Member 'PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent::ScriptedEventActor' has a wrong offset!");
static_assert(offsetof(PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent, ReturnValue) == 0x000008, "Member 'PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.CancelHeld
// 0x0004 (0x0004 - 0x0000)
struct WSPanel_CancelHeld final
{
public:
	float                                         TimeHeld;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_CancelHeld) == 0x000004, "Wrong alignment on WSPanel_CancelHeld");
static_assert(sizeof(WSPanel_CancelHeld) == 0x000004, "Wrong size on WSPanel_CancelHeld");
static_assert(offsetof(WSPanel_CancelHeld, TimeHeld) == 0x000000, "Member 'WSPanel_CancelHeld::TimeHeld' has a wrong offset!");

// Function Phoenix.WSPanel.ConfirmHeld
// 0x0004 (0x0004 - 0x0000)
struct WSPanel_ConfirmHeld final
{
public:
	float                                         TimeHeld;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_ConfirmHeld) == 0x000004, "Wrong alignment on WSPanel_ConfirmHeld");
static_assert(sizeof(WSPanel_ConfirmHeld) == 0x000004, "Wrong size on WSPanel_ConfirmHeld");
static_assert(offsetof(WSPanel_ConfirmHeld, TimeHeld) == 0x000000, "Member 'WSPanel_ConfirmHeld::TimeHeld' has a wrong offset!");

// Function Phoenix.WSPanel.FaceLeftHeld
// 0x0004 (0x0004 - 0x0000)
struct WSPanel_FaceLeftHeld final
{
public:
	float                                         TimeHeld;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_FaceLeftHeld) == 0x000004, "Wrong alignment on WSPanel_FaceLeftHeld");
static_assert(sizeof(WSPanel_FaceLeftHeld) == 0x000004, "Wrong size on WSPanel_FaceLeftHeld");
static_assert(offsetof(WSPanel_FaceLeftHeld, TimeHeld) == 0x000000, "Member 'WSPanel_FaceLeftHeld::TimeHeld' has a wrong offset!");

// Function Phoenix.WSPanel.FaceUpHeld
// 0x0004 (0x0004 - 0x0000)
struct WSPanel_FaceUpHeld final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_FaceUpHeld) == 0x000004, "Wrong alignment on WSPanel_FaceUpHeld");
static_assert(sizeof(WSPanel_FaceUpHeld) == 0x000004, "Wrong size on WSPanel_FaceUpHeld");
static_assert(offsetof(WSPanel_FaceUpHeld, DeltaTime) == 0x000000, "Member 'WSPanel_FaceUpHeld::DeltaTime' has a wrong offset!");

// Function Phoenix.WSPanel.HandleDirectionInput
// 0x0001 (0x0001 - 0x0000)
struct WSPanel_HandleDirectionInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_HandleDirectionInput) == 0x000001, "Wrong alignment on WSPanel_HandleDirectionInput");
static_assert(sizeof(WSPanel_HandleDirectionInput) == 0x000001, "Wrong size on WSPanel_HandleDirectionInput");
static_assert(offsetof(WSPanel_HandleDirectionInput, Direction) == 0x000000, "Member 'WSPanel_HandleDirectionInput::Direction' has a wrong offset!");

// Function Phoenix.WSPanel.PlayGlobalSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_PlayGlobalSound final
{
public:
	class UAkAudioEvent*                          Sound;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_PlayGlobalSound) == 0x000008, "Wrong alignment on WSPanel_PlayGlobalSound");
static_assert(sizeof(WSPanel_PlayGlobalSound) == 0x000008, "Wrong size on WSPanel_PlayGlobalSound");
static_assert(offsetof(WSPanel_PlayGlobalSound, Sound) == 0x000000, "Member 'WSPanel_PlayGlobalSound::Sound' has a wrong offset!");

// Function Phoenix.WSPanel.PlaySound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_PlaySound final
{
public:
	class UAkAudioEvent*                          Sound;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_PlaySound) == 0x000008, "Wrong alignment on WSPanel_PlaySound");
static_assert(sizeof(WSPanel_PlaySound) == 0x000008, "Wrong size on WSPanel_PlaySound");
static_assert(offsetof(WSPanel_PlaySound, Sound) == 0x000000, "Member 'WSPanel_PlaySound::Sound' has a wrong offset!");

// Function Phoenix.WSPanel.ReceiveHandleDirectionInput
// 0x0001 (0x0001 - 0x0000)
struct WSPanel_ReceiveHandleDirectionInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_ReceiveHandleDirectionInput) == 0x000001, "Wrong alignment on WSPanel_ReceiveHandleDirectionInput");
static_assert(sizeof(WSPanel_ReceiveHandleDirectionInput) == 0x000001, "Wrong size on WSPanel_ReceiveHandleDirectionInput");
static_assert(offsetof(WSPanel_ReceiveHandleDirectionInput, Direction) == 0x000000, "Member 'WSPanel_ReceiveHandleDirectionInput::Direction' has a wrong offset!");

// Function Phoenix.WSPanel.GetCancelSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetCancelSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetCancelSound) == 0x000008, "Wrong alignment on WSPanel_GetCancelSound");
static_assert(sizeof(WSPanel_GetCancelSound) == 0x000008, "Wrong size on WSPanel_GetCancelSound");
static_assert(offsetof(WSPanel_GetCancelSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetCancelSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetCloseSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetCloseSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetCloseSound) == 0x000008, "Wrong alignment on WSPanel_GetCloseSound");
static_assert(sizeof(WSPanel_GetCloseSound) == 0x000008, "Wrong size on WSPanel_GetCloseSound");
static_assert(offsetof(WSPanel_GetCloseSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetCloseSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetConfirmSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetConfirmSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetConfirmSound) == 0x000008, "Wrong alignment on WSPanel_GetConfirmSound");
static_assert(sizeof(WSPanel_GetConfirmSound) == 0x000008, "Wrong size on WSPanel_GetConfirmSound");
static_assert(offsetof(WSPanel_GetConfirmSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetConfirmSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetDeepestPanel
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetDeepestPanel final
{
public:
	class AWSPanel*                               ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetDeepestPanel) == 0x000008, "Wrong alignment on WSPanel_GetDeepestPanel");
static_assert(sizeof(WSPanel_GetDeepestPanel) == 0x000008, "Wrong size on WSPanel_GetDeepestPanel");
static_assert(offsetof(WSPanel_GetDeepestPanel, ReturnValue) == 0x000000, "Member 'WSPanel_GetDeepestPanel::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetNavDownSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetNavDownSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetNavDownSound) == 0x000008, "Wrong alignment on WSPanel_GetNavDownSound");
static_assert(sizeof(WSPanel_GetNavDownSound) == 0x000008, "Wrong size on WSPanel_GetNavDownSound");
static_assert(offsetof(WSPanel_GetNavDownSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetNavDownSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetNavLeftSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetNavLeftSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetNavLeftSound) == 0x000008, "Wrong alignment on WSPanel_GetNavLeftSound");
static_assert(sizeof(WSPanel_GetNavLeftSound) == 0x000008, "Wrong size on WSPanel_GetNavLeftSound");
static_assert(offsetof(WSPanel_GetNavLeftSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetNavLeftSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetNavRightSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetNavRightSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetNavRightSound) == 0x000008, "Wrong alignment on WSPanel_GetNavRightSound");
static_assert(sizeof(WSPanel_GetNavRightSound) == 0x000008, "Wrong size on WSPanel_GetNavRightSound");
static_assert(offsetof(WSPanel_GetNavRightSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetNavRightSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetNavUpSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetNavUpSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetNavUpSound) == 0x000008, "Wrong alignment on WSPanel_GetNavUpSound");
static_assert(sizeof(WSPanel_GetNavUpSound) == 0x000008, "Wrong size on WSPanel_GetNavUpSound");
static_assert(offsetof(WSPanel_GetNavUpSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetNavUpSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetOpenSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetOpenSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetOpenSound) == 0x000008, "Wrong alignment on WSPanel_GetOpenSound");
static_assert(sizeof(WSPanel_GetOpenSound) == 0x000008, "Wrong size on WSPanel_GetOpenSound");
static_assert(offsetof(WSPanel_GetOpenSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetOpenSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetParent
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetParent final
{
public:
	class AWSPanel*                               ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetParent) == 0x000008, "Wrong alignment on WSPanel_GetParent");
static_assert(sizeof(WSPanel_GetParent) == 0x000008, "Wrong size on WSPanel_GetParent");
static_assert(offsetof(WSPanel_GetParent, ReturnValue) == 0x000000, "Member 'WSPanel_GetParent::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetRelativeOffset
// 0x000C (0x000C - 0x0000)
struct WSPanel_GetRelativeOffset final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetRelativeOffset) == 0x000004, "Wrong alignment on WSPanel_GetRelativeOffset");
static_assert(sizeof(WSPanel_GetRelativeOffset) == 0x00000C, "Wrong size on WSPanel_GetRelativeOffset");
static_assert(offsetof(WSPanel_GetRelativeOffset, ReturnValue) == 0x000000, "Member 'WSPanel_GetRelativeOffset::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetRelativeScale
// 0x000C (0x000C - 0x0000)
struct WSPanel_GetRelativeScale final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetRelativeScale) == 0x000004, "Wrong alignment on WSPanel_GetRelativeScale");
static_assert(sizeof(WSPanel_GetRelativeScale) == 0x00000C, "Wrong size on WSPanel_GetRelativeScale");
static_assert(offsetof(WSPanel_GetRelativeScale, ReturnValue) == 0x000000, "Member 'WSPanel_GetRelativeScale::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetShoulderLeftSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetShoulderLeftSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetShoulderLeftSound) == 0x000008, "Wrong alignment on WSPanel_GetShoulderLeftSound");
static_assert(sizeof(WSPanel_GetShoulderLeftSound) == 0x000008, "Wrong size on WSPanel_GetShoulderLeftSound");
static_assert(offsetof(WSPanel_GetShoulderLeftSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetShoulderLeftSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanel.GetShoulderRightSound
// 0x0008 (0x0008 - 0x0000)
struct WSPanel_GetShoulderRightSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanel_GetShoulderRightSound) == 0x000008, "Wrong alignment on WSPanel_GetShoulderRightSound");
static_assert(sizeof(WSPanel_GetShoulderRightSound) == 0x000008, "Wrong size on WSPanel_GetShoulderRightSound");
static_assert(offsetof(WSPanel_GetShoulderRightSound, ReturnValue) == 0x000000, "Member 'WSPanel_GetShoulderRightSound::ReturnValue' has a wrong offset!");

// Function Phoenix.WSSkillTree.GatherTreeBranches
// 0x0010 (0x0010 - 0x0000)
struct WSSkillTree_GatherTreeBranches final
{
public:
	TArray<class USceneComponent*>                OutTreeBranches;                                   // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTree_GatherTreeBranches) == 0x000008, "Wrong alignment on WSSkillTree_GatherTreeBranches");
static_assert(sizeof(WSSkillTree_GatherTreeBranches) == 0x000010, "Wrong size on WSSkillTree_GatherTreeBranches");
static_assert(offsetof(WSSkillTree_GatherTreeBranches, OutTreeBranches) == 0x000000, "Member 'WSSkillTree_GatherTreeBranches::OutTreeBranches' has a wrong offset!");

// Function Phoenix.WSSkillTree.GatherTreeSelections
// 0x0010 (0x0010 - 0x0000)
struct WSSkillTree_GatherTreeSelections final
{
public:
	TArray<class UChildActorComponent*>           OutTreeSelections;                                 // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTree_GatherTreeSelections) == 0x000008, "Wrong alignment on WSSkillTree_GatherTreeSelections");
static_assert(sizeof(WSSkillTree_GatherTreeSelections) == 0x000010, "Wrong size on WSSkillTree_GatherTreeSelections");
static_assert(offsetof(WSSkillTree_GatherTreeSelections, OutTreeSelections) == 0x000000, "Member 'WSSkillTree_GatherTreeSelections::OutTreeSelections' has a wrong offset!");

// Function Phoenix.WSSkillTree.NotifyHologramUpgrades
// 0x0108 (0x0108 - 0x0000)
struct WSSkillTree_NotifyHologramUpgrades final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	const class UChildActorComponent*             SelectionComponent;                                // 0x0100(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTree_NotifyHologramUpgrades) == 0x000008, "Wrong alignment on WSSkillTree_NotifyHologramUpgrades");
static_assert(sizeof(WSSkillTree_NotifyHologramUpgrades) == 0x000108, "Wrong size on WSSkillTree_NotifyHologramUpgrades");
static_assert(offsetof(WSSkillTree_NotifyHologramUpgrades, ItemData) == 0x000000, "Member 'WSSkillTree_NotifyHologramUpgrades::ItemData' has a wrong offset!");
static_assert(offsetof(WSSkillTree_NotifyHologramUpgrades, SelectionComponent) == 0x000100, "Member 'WSSkillTree_NotifyHologramUpgrades::SelectionComponent' has a wrong offset!");

// Function Phoenix.WSSkillTree.NotifyHologramVisibility
// 0x0008 (0x0008 - 0x0000)
struct WSSkillTree_NotifyHologramVisibility final
{
public:
	int32                                         Index_0;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bVisible;                                          // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WSSkillTree_NotifyHologramVisibility) == 0x000004, "Wrong alignment on WSSkillTree_NotifyHologramVisibility");
static_assert(sizeof(WSSkillTree_NotifyHologramVisibility) == 0x000008, "Wrong size on WSSkillTree_NotifyHologramVisibility");
static_assert(offsetof(WSSkillTree_NotifyHologramVisibility, Index_0) == 0x000000, "Member 'WSSkillTree_NotifyHologramVisibility::Index_0' has a wrong offset!");
static_assert(offsetof(WSSkillTree_NotifyHologramVisibility, bVisible) == 0x000004, "Member 'WSSkillTree_NotifyHologramVisibility::bVisible' has a wrong offset!");

// Function Phoenix.WSSkillTree.GetCurrentBranchIndex
// 0x0004 (0x0004 - 0x0000)
struct WSSkillTree_GetCurrentBranchIndex final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTree_GetCurrentBranchIndex) == 0x000004, "Wrong alignment on WSSkillTree_GetCurrentBranchIndex");
static_assert(sizeof(WSSkillTree_GetCurrentBranchIndex) == 0x000004, "Wrong size on WSSkillTree_GetCurrentBranchIndex");
static_assert(offsetof(WSSkillTree_GetCurrentBranchIndex, ReturnValue) == 0x000000, "Member 'WSSkillTree_GetCurrentBranchIndex::ReturnValue' has a wrong offset!");

// Function Phoenix.WSSkillTree.GetSelected
// 0x0008 (0x0008 - 0x0000)
struct WSSkillTree_GetSelected final
{
public:
	class AWSSkillTreeButton*                     ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTree_GetSelected) == 0x000008, "Wrong alignment on WSSkillTree_GetSelected");
static_assert(sizeof(WSSkillTree_GetSelected) == 0x000008, "Wrong size on WSSkillTree_GetSelected");
static_assert(offsetof(WSSkillTree_GetSelected, ReturnValue) == 0x000000, "Member 'WSSkillTree_GetSelected::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxKeyboardSelectable.SetKeyMapped
// 0x0001 (0x0001 - 0x0000)
struct PhxKeyboardSelectable_SetKeyMapped final
{
public:
	bool                                          bMapped;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxKeyboardSelectable_SetKeyMapped) == 0x000001, "Wrong alignment on PhxKeyboardSelectable_SetKeyMapped");
static_assert(sizeof(PhxKeyboardSelectable_SetKeyMapped) == 0x000001, "Wrong size on PhxKeyboardSelectable_SetKeyMapped");
static_assert(offsetof(PhxKeyboardSelectable_SetKeyMapped, bMapped) == 0x000000, "Member 'PhxKeyboardSelectable_SetKeyMapped::bMapped' has a wrong offset!");

// Function Phoenix.PhxKeyboardSelectable.SetKeyValue
// 0x0018 (0x0018 - 0x0000)
struct PhxKeyboardSelectable_SetKeyValue final
{
public:
	struct FKey                                   KeyValue;                                          // 0x0000(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxKeyboardSelectable_SetKeyValue) == 0x000008, "Wrong alignment on PhxKeyboardSelectable_SetKeyValue");
static_assert(sizeof(PhxKeyboardSelectable_SetKeyValue) == 0x000018, "Wrong size on PhxKeyboardSelectable_SetKeyValue");
static_assert(offsetof(PhxKeyboardSelectable_SetKeyValue, KeyValue) == 0x000000, "Member 'PhxKeyboardSelectable_SetKeyValue::KeyValue' has a wrong offset!");

// Function Phoenix.PhxKeyboardSelectable.IsKeyMapped
// 0x0001 (0x0001 - 0x0000)
struct PhxKeyboardSelectable_IsKeyMapped final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxKeyboardSelectable_IsKeyMapped) == 0x000001, "Wrong alignment on PhxKeyboardSelectable_IsKeyMapped");
static_assert(sizeof(PhxKeyboardSelectable_IsKeyMapped) == 0x000001, "Wrong size on PhxKeyboardSelectable_IsKeyMapped");
static_assert(offsetof(PhxKeyboardSelectable_IsKeyMapped, ReturnValue) == 0x000000, "Member 'PhxKeyboardSelectable_IsKeyMapped::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxKeyboardSelectable.KeyValue
// 0x0018 (0x0018 - 0x0000)
struct PhxKeyboardSelectable_KeyValue final
{
public:
	struct FKey                                   ReturnValue;                                       // 0x0000(0x0018)(Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxKeyboardSelectable_KeyValue) == 0x000008, "Wrong alignment on PhxKeyboardSelectable_KeyValue");
static_assert(sizeof(PhxKeyboardSelectable_KeyValue) == 0x000018, "Wrong size on PhxKeyboardSelectable_KeyValue");
static_assert(offsetof(PhxKeyboardSelectable_KeyValue, ReturnValue) == 0x000000, "Member 'PhxKeyboardSelectable_KeyValue::ReturnValue' has a wrong offset!");

// Function Phoenix.AimState.AimIdle_Begin
// 0x0008 (0x0008 - 0x0000)
struct AimState_AimIdle_Begin final
{
public:
	const class UStateParams*                     Params_0;                                          // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AimState_AimIdle_Begin) == 0x000008, "Wrong alignment on AimState_AimIdle_Begin");
static_assert(sizeof(AimState_AimIdle_Begin) == 0x000008, "Wrong size on AimState_AimIdle_Begin");
static_assert(offsetof(AimState_AimIdle_Begin, Params_0) == 0x000000, "Member 'AimState_AimIdle_Begin::Params_0' has a wrong offset!");

// Function Phoenix.AimState.AuxShoot_Begin
// 0x0008 (0x0008 - 0x0000)
struct AimState_AuxShoot_Begin final
{
public:
	const class UStateParams*                     Params_0;                                          // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AimState_AuxShoot_Begin) == 0x000008, "Wrong alignment on AimState_AuxShoot_Begin");
static_assert(sizeof(AimState_AuxShoot_Begin) == 0x000008, "Wrong size on AimState_AuxShoot_Begin");
static_assert(offsetof(AimState_AuxShoot_Begin, Params_0) == 0x000000, "Member 'AimState_AuxShoot_Begin::Params_0' has a wrong offset!");

// Function Phoenix.AimState.Shoot_Begin
// 0x0008 (0x0008 - 0x0000)
struct AimState_Shoot_Begin final
{
public:
	const class UStateParams*                     Params_0;                                          // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AimState_Shoot_Begin) == 0x000008, "Wrong alignment on AimState_Shoot_Begin");
static_assert(sizeof(AimState_Shoot_Begin) == 0x000008, "Wrong size on AimState_Shoot_Begin");
static_assert(offsetof(AimState_Shoot_Begin, Params_0) == 0x000000, "Member 'AimState_Shoot_Begin::Params_0' has a wrong offset!");

// Function Phoenix.AIPPEResponseState.OnTakeAnyDamage
// 0x0028 (0x0028 - 0x0000)
struct AIPPEResponseState_OnTakeAnyDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AIPPEResponseState_OnTakeAnyDamage) == 0x000008, "Wrong alignment on AIPPEResponseState_OnTakeAnyDamage");
static_assert(sizeof(AIPPEResponseState_OnTakeAnyDamage) == 0x000028, "Wrong size on AIPPEResponseState_OnTakeAnyDamage");
static_assert(offsetof(AIPPEResponseState_OnTakeAnyDamage, DamagedActor) == 0x000000, "Member 'AIPPEResponseState_OnTakeAnyDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(AIPPEResponseState_OnTakeAnyDamage, Damage) == 0x000008, "Member 'AIPPEResponseState_OnTakeAnyDamage::Damage' has a wrong offset!");
static_assert(offsetof(AIPPEResponseState_OnTakeAnyDamage, DamageType) == 0x000010, "Member 'AIPPEResponseState_OnTakeAnyDamage::DamageType' has a wrong offset!");
static_assert(offsetof(AIPPEResponseState_OnTakeAnyDamage, InstigatedBy) == 0x000018, "Member 'AIPPEResponseState_OnTakeAnyDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(AIPPEResponseState_OnTakeAnyDamage, DamageCauser) == 0x000020, "Member 'AIPPEResponseState_OnTakeAnyDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxAudioPhysicsComponent.HandleCollisionSounds
// 0x00B0 (0x00B0 - 0x0000)
struct PhxAudioPhysicsComponent_HandleCollisionSounds final
{
public:
	class UPrimitiveComponent*                    SelfComp;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAudioPhysicsComponent_HandleCollisionSounds) == 0x000008, "Wrong alignment on PhxAudioPhysicsComponent_HandleCollisionSounds");
static_assert(sizeof(PhxAudioPhysicsComponent_HandleCollisionSounds) == 0x0000B0, "Wrong size on PhxAudioPhysicsComponent_HandleCollisionSounds");
static_assert(offsetof(PhxAudioPhysicsComponent_HandleCollisionSounds, SelfComp) == 0x000000, "Member 'PhxAudioPhysicsComponent_HandleCollisionSounds::SelfComp' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandleCollisionSounds, OtherActor) == 0x000008, "Member 'PhxAudioPhysicsComponent_HandleCollisionSounds::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandleCollisionSounds, OtherComp) == 0x000010, "Member 'PhxAudioPhysicsComponent_HandleCollisionSounds::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandleCollisionSounds, NormalImpulse) == 0x000018, "Member 'PhxAudioPhysicsComponent_HandleCollisionSounds::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandleCollisionSounds, Hit) == 0x000024, "Member 'PhxAudioPhysicsComponent_HandleCollisionSounds::Hit' has a wrong offset!");

// Function Phoenix.PhxAudioPhysicsComponent.HandlePointDamage
// 0x0058 (0x0058 - 0x0000)
struct PhxAudioPhysicsComponent_HandlePointDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class AController*                            InstigatedBy;                                      // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                HitLocation;                                       // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPrimitiveComponent*                    FHitComponent;                                     // 0x0028(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BoneName;                                          // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ShotFromDirection;                                 // 0x0038(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0048(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0050(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioPhysicsComponent_HandlePointDamage) == 0x000008, "Wrong alignment on PhxAudioPhysicsComponent_HandlePointDamage");
static_assert(sizeof(PhxAudioPhysicsComponent_HandlePointDamage) == 0x000058, "Wrong size on PhxAudioPhysicsComponent_HandlePointDamage");
static_assert(offsetof(PhxAudioPhysicsComponent_HandlePointDamage, DamagedActor) == 0x000000, "Member 'PhxAudioPhysicsComponent_HandlePointDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandlePointDamage, Damage) == 0x000008, "Member 'PhxAudioPhysicsComponent_HandlePointDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandlePointDamage, InstigatedBy) == 0x000010, "Member 'PhxAudioPhysicsComponent_HandlePointDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandlePointDamage, HitLocation) == 0x000018, "Member 'PhxAudioPhysicsComponent_HandlePointDamage::HitLocation' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandlePointDamage, FHitComponent) == 0x000028, "Member 'PhxAudioPhysicsComponent_HandlePointDamage::FHitComponent' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandlePointDamage, BoneName) == 0x000030, "Member 'PhxAudioPhysicsComponent_HandlePointDamage::BoneName' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandlePointDamage, ShotFromDirection) == 0x000038, "Member 'PhxAudioPhysicsComponent_HandlePointDamage::ShotFromDirection' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandlePointDamage, DamageType) == 0x000048, "Member 'PhxAudioPhysicsComponent_HandlePointDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_HandlePointDamage, DamageCauser) == 0x000050, "Member 'PhxAudioPhysicsComponent_HandlePointDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxAudioPhysicsComponent.OnHitEventDone
// 0x0010 (0x0010 - 0x0000)
struct PhxAudioPhysicsComponent_OnHitEventDone final
{
public:
	EAkCallbackType                               CallbackType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UAkCallbackInfo*                        CallbackInfo;                                      // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioPhysicsComponent_OnHitEventDone) == 0x000008, "Wrong alignment on PhxAudioPhysicsComponent_OnHitEventDone");
static_assert(sizeof(PhxAudioPhysicsComponent_OnHitEventDone) == 0x000010, "Wrong size on PhxAudioPhysicsComponent_OnHitEventDone");
static_assert(offsetof(PhxAudioPhysicsComponent_OnHitEventDone, CallbackType) == 0x000000, "Member 'PhxAudioPhysicsComponent_OnHitEventDone::CallbackType' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsComponent_OnHitEventDone, CallbackInfo) == 0x000008, "Member 'PhxAudioPhysicsComponent_OnHitEventDone::CallbackInfo' has a wrong offset!");

// Function Phoenix.AmmoDisplay.AttachToWeapon
// 0x0008 (0x0008 - 0x0000)
struct AmmoDisplay_AttachToWeapon final
{
public:
	class USceneComponent*                        ParentWeapon;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_AttachToWeapon) == 0x000008, "Wrong alignment on AmmoDisplay_AttachToWeapon");
static_assert(sizeof(AmmoDisplay_AttachToWeapon) == 0x000008, "Wrong size on AmmoDisplay_AttachToWeapon");
static_assert(offsetof(AmmoDisplay_AttachToWeapon, ParentWeapon) == 0x000000, "Member 'AmmoDisplay_AttachToWeapon::ParentWeapon' has a wrong offset!");

// Function Phoenix.AmmoDisplay.PlayAmmoChangeSound
// 0x0008 (0x0008 - 0x0000)
struct AmmoDisplay_PlayAmmoChangeSound final
{
public:
	int32                                         AmmoDelta;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NewAmmoCount;                                      // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_PlayAmmoChangeSound) == 0x000004, "Wrong alignment on AmmoDisplay_PlayAmmoChangeSound");
static_assert(sizeof(AmmoDisplay_PlayAmmoChangeSound) == 0x000008, "Wrong size on AmmoDisplay_PlayAmmoChangeSound");
static_assert(offsetof(AmmoDisplay_PlayAmmoChangeSound, AmmoDelta) == 0x000000, "Member 'AmmoDisplay_PlayAmmoChangeSound::AmmoDelta' has a wrong offset!");
static_assert(offsetof(AmmoDisplay_PlayAmmoChangeSound, NewAmmoCount) == 0x000004, "Member 'AmmoDisplay_PlayAmmoChangeSound::NewAmmoCount' has a wrong offset!");

// Function Phoenix.AmmoDisplay.SetActiveRounds
// 0x0004 (0x0004 - 0x0000)
struct AmmoDisplay_SetActiveRounds final
{
public:
	int32                                         Rounds;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_SetActiveRounds) == 0x000004, "Wrong alignment on AmmoDisplay_SetActiveRounds");
static_assert(sizeof(AmmoDisplay_SetActiveRounds) == 0x000004, "Wrong size on AmmoDisplay_SetActiveRounds");
static_assert(offsetof(AmmoDisplay_SetActiveRounds, Rounds) == 0x000000, "Member 'AmmoDisplay_SetActiveRounds::Rounds' has a wrong offset!");

// Function Phoenix.AmmoDisplay.SetClipSize
// 0x0004 (0x0004 - 0x0000)
struct AmmoDisplay_SetClipSize final
{
public:
	int32                                         ClipSize;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_SetClipSize) == 0x000004, "Wrong alignment on AmmoDisplay_SetClipSize");
static_assert(sizeof(AmmoDisplay_SetClipSize) == 0x000004, "Wrong size on AmmoDisplay_SetClipSize");
static_assert(offsetof(AmmoDisplay_SetClipSize, ClipSize) == 0x000000, "Member 'AmmoDisplay_SetClipSize::ClipSize' has a wrong offset!");

// Function Phoenix.AmmoDisplay.SetCountersVisible
// 0x0001 (0x0001 - 0x0000)
struct AmmoDisplay_SetCountersVisible final
{
public:
	bool                                          Visible;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_SetCountersVisible) == 0x000001, "Wrong alignment on AmmoDisplay_SetCountersVisible");
static_assert(sizeof(AmmoDisplay_SetCountersVisible) == 0x000001, "Wrong size on AmmoDisplay_SetCountersVisible");
static_assert(offsetof(AmmoDisplay_SetCountersVisible, Visible) == 0x000000, "Member 'AmmoDisplay_SetCountersVisible::Visible' has a wrong offset!");

// Function Phoenix.AmmoDisplay.SetReloadVisible
// 0x0001 (0x0001 - 0x0000)
struct AmmoDisplay_SetReloadVisible final
{
public:
	bool                                          Visible;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_SetReloadVisible) == 0x000001, "Wrong alignment on AmmoDisplay_SetReloadVisible");
static_assert(sizeof(AmmoDisplay_SetReloadVisible) == 0x000001, "Wrong size on AmmoDisplay_SetReloadVisible");
static_assert(offsetof(AmmoDisplay_SetReloadVisible, Visible) == 0x000000, "Member 'AmmoDisplay_SetReloadVisible::Visible' has a wrong offset!");

// Function Phoenix.AmmoDisplay.SetReserveRounds
// 0x0004 (0x0004 - 0x0000)
struct AmmoDisplay_SetReserveRounds final
{
public:
	int32                                         ReserveRounds;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_SetReserveRounds) == 0x000004, "Wrong alignment on AmmoDisplay_SetReserveRounds");
static_assert(sizeof(AmmoDisplay_SetReserveRounds) == 0x000004, "Wrong size on AmmoDisplay_SetReserveRounds");
static_assert(offsetof(AmmoDisplay_SetReserveRounds, ReserveRounds) == 0x000000, "Member 'AmmoDisplay_SetReserveRounds::ReserveRounds' has a wrong offset!");

// Function Phoenix.AmmoDisplay.SetSecondaryRounds
// 0x0004 (0x0004 - 0x0000)
struct AmmoDisplay_SetSecondaryRounds final
{
public:
	int32                                         Rounds;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_SetSecondaryRounds) == 0x000004, "Wrong alignment on AmmoDisplay_SetSecondaryRounds");
static_assert(sizeof(AmmoDisplay_SetSecondaryRounds) == 0x000004, "Wrong size on AmmoDisplay_SetSecondaryRounds");
static_assert(offsetof(AmmoDisplay_SetSecondaryRounds, Rounds) == 0x000000, "Member 'AmmoDisplay_SetSecondaryRounds::Rounds' has a wrong offset!");

// Function Phoenix.AmmoDisplay.SetSecondaryUnlocked
// 0x0001 (0x0001 - 0x0000)
struct AmmoDisplay_SetSecondaryUnlocked final
{
public:
	bool                                          Active;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_SetSecondaryUnlocked) == 0x000001, "Wrong alignment on AmmoDisplay_SetSecondaryUnlocked");
static_assert(sizeof(AmmoDisplay_SetSecondaryUnlocked) == 0x000001, "Wrong size on AmmoDisplay_SetSecondaryUnlocked");
static_assert(offsetof(AmmoDisplay_SetSecondaryUnlocked, Active) == 0x000000, "Member 'AmmoDisplay_SetSecondaryUnlocked::Active' has a wrong offset!");

// Function Phoenix.AmmoDisplay.SetVisible
// 0x0001 (0x0001 - 0x0000)
struct AmmoDisplay_SetVisible final
{
public:
	bool                                          Visible;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoDisplay_SetVisible) == 0x000001, "Wrong alignment on AmmoDisplay_SetVisible");
static_assert(sizeof(AmmoDisplay_SetVisible) == 0x000001, "Wrong size on AmmoDisplay_SetVisible");
static_assert(offsetof(AmmoDisplay_SetVisible, Visible) == 0x000000, "Member 'AmmoDisplay_SetVisible::Visible' has a wrong offset!");

// Function Phoenix.PhxCharacterDynMatPropagator.OnPlayerSkinChanged
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterDynMatPropagator_OnPlayerSkinChanged final
{
public:
	class UPhxCharacterSkin*                      NewSkin;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterDynMatPropagator_OnPlayerSkinChanged) == 0x000008, "Wrong alignment on PhxCharacterDynMatPropagator_OnPlayerSkinChanged");
static_assert(sizeof(PhxCharacterDynMatPropagator_OnPlayerSkinChanged) == 0x000008, "Wrong size on PhxCharacterDynMatPropagator_OnPlayerSkinChanged");
static_assert(offsetof(PhxCharacterDynMatPropagator_OnPlayerSkinChanged, NewSkin) == 0x000000, "Member 'PhxCharacterDynMatPropagator_OnPlayerSkinChanged::NewSkin' has a wrong offset!");

// Function Phoenix.PhxCharacterDynMatPropagator.SetMaterialByNameDoNotPropagate
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate final
{
public:
	class FName                                   MaterialSlotName;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     Material;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate) == 0x000008, "Wrong alignment on PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate");
static_assert(sizeof(PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate) == 0x000010, "Wrong size on PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate");
static_assert(offsetof(PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate, MaterialSlotName) == 0x000000, "Member 'PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate::MaterialSlotName' has a wrong offset!");
static_assert(offsetof(PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate, Material) == 0x000008, "Member 'PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate::Material' has a wrong offset!");

// Function Phoenix.PhxCharacterDynMatPropagator.SetMaterialDoNotPropagate
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate final
{
public:
	int32                                         ElementIndex;                                      // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UMaterialInterface*                     Material;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate) == 0x000008, "Wrong alignment on PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate");
static_assert(sizeof(PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate) == 0x000010, "Wrong size on PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate");
static_assert(offsetof(PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate, ElementIndex) == 0x000000, "Member 'PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate::ElementIndex' has a wrong offset!");
static_assert(offsetof(PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate, Material) == 0x000008, "Member 'PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate::Material' has a wrong offset!");

// Function Phoenix.DevMenuLibrary.GetDevFunctionColor
// 0x0020 (0x0020 - 0x0000)
struct DevMenuLibrary_GetDevFunctionColor final
{
public:
	class FString                                 FuncName;                                          // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ReturnValue;                                       // 0x0010(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(DevMenuLibrary_GetDevFunctionColor) == 0x000008, "Wrong alignment on DevMenuLibrary_GetDevFunctionColor");
static_assert(sizeof(DevMenuLibrary_GetDevFunctionColor) == 0x000020, "Wrong size on DevMenuLibrary_GetDevFunctionColor");
static_assert(offsetof(DevMenuLibrary_GetDevFunctionColor, FuncName) == 0x000000, "Member 'DevMenuLibrary_GetDevFunctionColor::FuncName' has a wrong offset!");
static_assert(offsetof(DevMenuLibrary_GetDevFunctionColor, ReturnValue) == 0x000010, "Member 'DevMenuLibrary_GetDevFunctionColor::ReturnValue' has a wrong offset!");

// Function Phoenix.DevMenuLibrary.GetDevFunctionNameSuffix
// 0x0020 (0x0020 - 0x0000)
struct DevMenuLibrary_GetDevFunctionNameSuffix final
{
public:
	class FString                                 FuncName;                                          // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ReturnValue;                                       // 0x0010(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(DevMenuLibrary_GetDevFunctionNameSuffix) == 0x000008, "Wrong alignment on DevMenuLibrary_GetDevFunctionNameSuffix");
static_assert(sizeof(DevMenuLibrary_GetDevFunctionNameSuffix) == 0x000020, "Wrong size on DevMenuLibrary_GetDevFunctionNameSuffix");
static_assert(offsetof(DevMenuLibrary_GetDevFunctionNameSuffix, FuncName) == 0x000000, "Member 'DevMenuLibrary_GetDevFunctionNameSuffix::FuncName' has a wrong offset!");
static_assert(offsetof(DevMenuLibrary_GetDevFunctionNameSuffix, ReturnValue) == 0x000010, "Member 'DevMenuLibrary_GetDevFunctionNameSuffix::ReturnValue' has a wrong offset!");

// Function Phoenix.DevMenuLibrary.GetIntCVarMenuColor
// 0x0020 (0x0020 - 0x0000)
struct DevMenuLibrary_GetIntCVarMenuColor final
{
public:
	class FString                                 CVarName;                                          // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ReturnValue;                                       // 0x0010(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(DevMenuLibrary_GetIntCVarMenuColor) == 0x000008, "Wrong alignment on DevMenuLibrary_GetIntCVarMenuColor");
static_assert(sizeof(DevMenuLibrary_GetIntCVarMenuColor) == 0x000020, "Wrong size on DevMenuLibrary_GetIntCVarMenuColor");
static_assert(offsetof(DevMenuLibrary_GetIntCVarMenuColor, CVarName) == 0x000000, "Member 'DevMenuLibrary_GetIntCVarMenuColor::CVarName' has a wrong offset!");
static_assert(offsetof(DevMenuLibrary_GetIntCVarMenuColor, ReturnValue) == 0x000010, "Member 'DevMenuLibrary_GetIntCVarMenuColor::ReturnValue' has a wrong offset!");

// Function Phoenix.HologramPanelComponent.GetDynamicMaterial
// 0x0008 (0x0008 - 0x0000)
struct HologramPanelComponent_GetDynamicMaterial final
{
public:
	class UMaterialInstanceDynamic*               ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HologramPanelComponent_GetDynamicMaterial) == 0x000008, "Wrong alignment on HologramPanelComponent_GetDynamicMaterial");
static_assert(sizeof(HologramPanelComponent_GetDynamicMaterial) == 0x000008, "Wrong size on HologramPanelComponent_GetDynamicMaterial");
static_assert(offsetof(HologramPanelComponent_GetDynamicMaterial, ReturnValue) == 0x000000, "Member 'HologramPanelComponent_GetDynamicMaterial::ReturnValue' has a wrong offset!");

// Function Phoenix.HologramPanelComponent.UpdateRotation
// 0x0004 (0x0004 - 0x0000)
struct HologramPanelComponent_UpdateRotation final
{
public:
	float                                         Output;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HologramPanelComponent_UpdateRotation) == 0x000004, "Wrong alignment on HologramPanelComponent_UpdateRotation");
static_assert(sizeof(HologramPanelComponent_UpdateRotation) == 0x000004, "Wrong size on HologramPanelComponent_UpdateRotation");
static_assert(offsetof(HologramPanelComponent_UpdateRotation, Output) == 0x000000, "Member 'HologramPanelComponent_UpdateRotation::Output' has a wrong offset!");

// Function Phoenix.HologramPanelComponent.UpdateScaleAndIntensity
// 0x0004 (0x0004 - 0x0000)
struct HologramPanelComponent_UpdateScaleAndIntensity final
{
public:
	float                                         Output;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HologramPanelComponent_UpdateScaleAndIntensity) == 0x000004, "Wrong alignment on HologramPanelComponent_UpdateScaleAndIntensity");
static_assert(sizeof(HologramPanelComponent_UpdateScaleAndIntensity) == 0x000004, "Wrong size on HologramPanelComponent_UpdateScaleAndIntensity");
static_assert(offsetof(HologramPanelComponent_UpdateScaleAndIntensity, Output) == 0x000000, "Member 'HologramPanelComponent_UpdateScaleAndIntensity::Output' has a wrong offset!");

// Function Phoenix.PhxDecalLightFixture.InitializeDecalLightFixture
// 0x0001 (0x0001 - 0x0000)
struct PhxDecalLightFixture_InitializeDecalLightFixture final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDecalLightFixture_InitializeDecalLightFixture) == 0x000001, "Wrong alignment on PhxDecalLightFixture_InitializeDecalLightFixture");
static_assert(sizeof(PhxDecalLightFixture_InitializeDecalLightFixture) == 0x000001, "Wrong size on PhxDecalLightFixture_InitializeDecalLightFixture");
static_assert(offsetof(PhxDecalLightFixture_InitializeDecalLightFixture, ReturnValue) == 0x000000, "Member 'PhxDecalLightFixture_InitializeDecalLightFixture::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDecalLightFixture.UpdateFlickerTimelineFunc
// 0x0004 (0x0004 - 0x0000)
struct PhxDecalLightFixture_UpdateFlickerTimelineFunc final
{
public:
	float                                         OutputFlickerPattern;                              // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDecalLightFixture_UpdateFlickerTimelineFunc) == 0x000004, "Wrong alignment on PhxDecalLightFixture_UpdateFlickerTimelineFunc");
static_assert(sizeof(PhxDecalLightFixture_UpdateFlickerTimelineFunc) == 0x000004, "Wrong size on PhxDecalLightFixture_UpdateFlickerTimelineFunc");
static_assert(offsetof(PhxDecalLightFixture_UpdateFlickerTimelineFunc, OutputFlickerPattern) == 0x000000, "Member 'PhxDecalLightFixture_UpdateFlickerTimelineFunc::OutputFlickerPattern' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.HandleActorOverlapBeginTrigger
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroup_HandleActorOverlapBeginTrigger final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_HandleActorOverlapBeginTrigger) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_HandleActorOverlapBeginTrigger");
static_assert(sizeof(PhxAIEncounterGroup_HandleActorOverlapBeginTrigger) == 0x000010, "Wrong size on PhxAIEncounterGroup_HandleActorOverlapBeginTrigger");
static_assert(offsetof(PhxAIEncounterGroup_HandleActorOverlapBeginTrigger, OverlappedActor) == 0x000000, "Member 'PhxAIEncounterGroup_HandleActorOverlapBeginTrigger::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleActorOverlapBeginTrigger, OtherActor) == 0x000008, "Member 'PhxAIEncounterGroup_HandleActorOverlapBeginTrigger::OtherActor' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.HandleActorOverlapDespawnTrigger
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger");
static_assert(sizeof(PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger) == 0x000010, "Wrong size on PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger");
static_assert(offsetof(PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger, OverlappedActor) == 0x000000, "Member 'PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger, OtherActor) == 0x000008, "Member 'PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger::OtherActor' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.HandleAIDestroyed
// 0x0008 (0x0008 - 0x0000)
struct PhxAIEncounterGroup_HandleAIDestroyed final
{
public:
	class AActor*                                 DestroyedActor;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_HandleAIDestroyed) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_HandleAIDestroyed");
static_assert(sizeof(PhxAIEncounterGroup_HandleAIDestroyed) == 0x000008, "Wrong size on PhxAIEncounterGroup_HandleAIDestroyed");
static_assert(offsetof(PhxAIEncounterGroup_HandleAIDestroyed, DestroyedActor) == 0x000000, "Member 'PhxAIEncounterGroup_HandleAIDestroyed::DestroyedActor' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.HandleAIDied
// 0x0020 (0x0020 - 0x0000)
struct PhxAIEncounterGroup_HandleAIDied final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIEncounterGroup_HandleAIDied) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_HandleAIDied");
static_assert(sizeof(PhxAIEncounterGroup_HandleAIDied) == 0x000020, "Wrong size on PhxAIEncounterGroup_HandleAIDied");
static_assert(offsetof(PhxAIEncounterGroup_HandleAIDied, DeadCharacter) == 0x000000, "Member 'PhxAIEncounterGroup_HandleAIDied::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleAIDied, KillerActor) == 0x000008, "Member 'PhxAIEncounterGroup_HandleAIDied::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleAIDied, KillerController) == 0x000010, "Member 'PhxAIEncounterGroup_HandleAIDied::KillerController' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleAIDied, KillingBlowHealthDelta) == 0x000018, "Member 'PhxAIEncounterGroup_HandleAIDied::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.HandleAILimboBegin
// 0x0008 (0x0008 - 0x0000)
struct PhxAIEncounterGroup_HandleAILimboBegin final
{
public:
	class APhxCharacter*                          CharacterInLimbo;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_HandleAILimboBegin) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_HandleAILimboBegin");
static_assert(sizeof(PhxAIEncounterGroup_HandleAILimboBegin) == 0x000008, "Wrong size on PhxAIEncounterGroup_HandleAILimboBegin");
static_assert(offsetof(PhxAIEncounterGroup_HandleAILimboBegin, CharacterInLimbo) == 0x000000, "Member 'PhxAIEncounterGroup_HandleAILimboBegin::CharacterInLimbo' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.HandleAILimboEnd
// 0x0008 (0x0008 - 0x0000)
struct PhxAIEncounterGroup_HandleAILimboEnd final
{
public:
	class APhxCharacter*                          CharacterInLimbo;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_HandleAILimboEnd) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_HandleAILimboEnd");
static_assert(sizeof(PhxAIEncounterGroup_HandleAILimboEnd) == 0x000008, "Wrong size on PhxAIEncounterGroup_HandleAILimboEnd");
static_assert(offsetof(PhxAIEncounterGroup_HandleAILimboEnd, CharacterInLimbo) == 0x000000, "Member 'PhxAIEncounterGroup_HandleAILimboEnd::CharacterInLimbo' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.HandleAISpawned
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroup_HandleAISpawned final
{
public:
	class APhxAICharacter*                        SpawnedAI;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAISpawnResultCode                         ResultCode;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SpawnUid;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_HandleAISpawned) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_HandleAISpawned");
static_assert(sizeof(PhxAIEncounterGroup_HandleAISpawned) == 0x000010, "Wrong size on PhxAIEncounterGroup_HandleAISpawned");
static_assert(offsetof(PhxAIEncounterGroup_HandleAISpawned, SpawnedAI) == 0x000000, "Member 'PhxAIEncounterGroup_HandleAISpawned::SpawnedAI' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleAISpawned, ResultCode) == 0x000008, "Member 'PhxAIEncounterGroup_HandleAISpawned::ResultCode' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleAISpawned, SpawnUid) == 0x00000C, "Member 'PhxAIEncounterGroup_HandleAISpawned::SpawnUid' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.HandleAITakeAnyDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxAIEncounterGroup_HandleAITakeAnyDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_HandleAITakeAnyDamage) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_HandleAITakeAnyDamage");
static_assert(sizeof(PhxAIEncounterGroup_HandleAITakeAnyDamage) == 0x000028, "Wrong size on PhxAIEncounterGroup_HandleAITakeAnyDamage");
static_assert(offsetof(PhxAIEncounterGroup_HandleAITakeAnyDamage, DamagedActor) == 0x000000, "Member 'PhxAIEncounterGroup_HandleAITakeAnyDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleAITakeAnyDamage, Damage) == 0x000008, "Member 'PhxAIEncounterGroup_HandleAITakeAnyDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleAITakeAnyDamage, DamageType) == 0x000010, "Member 'PhxAIEncounterGroup_HandleAITakeAnyDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleAITakeAnyDamage, InstigatedBy) == 0x000018, "Member 'PhxAIEncounterGroup_HandleAITakeAnyDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_HandleAITakeAnyDamage, DamageCauser) == 0x000020, "Member 'PhxAIEncounterGroup_HandleAITakeAnyDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.GetAliveAIByCharacterTag
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroup_GetAliveAIByCharacterTag final
{
public:
	class FName                                   CharacterTag;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_GetAliveAIByCharacterTag) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_GetAliveAIByCharacterTag");
static_assert(sizeof(PhxAIEncounterGroup_GetAliveAIByCharacterTag) == 0x000010, "Wrong size on PhxAIEncounterGroup_GetAliveAIByCharacterTag");
static_assert(offsetof(PhxAIEncounterGroup_GetAliveAIByCharacterTag, CharacterTag) == 0x000000, "Member 'PhxAIEncounterGroup_GetAliveAIByCharacterTag::CharacterTag' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_GetAliveAIByCharacterTag, ReturnValue) == 0x000008, "Member 'PhxAIEncounterGroup_GetAliveAIByCharacterTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.GetAllAliveAI_BP
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroup_GetAllAliveAI_BP final
{
public:
	TArray<class APhxAICharacter*>                ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_GetAllAliveAI_BP) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_GetAllAliveAI_BP");
static_assert(sizeof(PhxAIEncounterGroup_GetAllAliveAI_BP) == 0x000010, "Wrong size on PhxAIEncounterGroup_GetAllAliveAI_BP");
static_assert(offsetof(PhxAIEncounterGroup_GetAllAliveAI_BP, ReturnValue) == 0x000000, "Member 'PhxAIEncounterGroup_GetAllAliveAI_BP::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.GetAllAliveAIForWave_BP
// 0x0018 (0x0018 - 0x0000)
struct PhxAIEncounterGroup_GetAllAliveAIForWave_BP final
{
public:
	class FName                                   Tag;                                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class APhxAICharacter*>                ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_GetAllAliveAIForWave_BP) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_GetAllAliveAIForWave_BP");
static_assert(sizeof(PhxAIEncounterGroup_GetAllAliveAIForWave_BP) == 0x000018, "Wrong size on PhxAIEncounterGroup_GetAllAliveAIForWave_BP");
static_assert(offsetof(PhxAIEncounterGroup_GetAllAliveAIForWave_BP, Tag) == 0x000000, "Member 'PhxAIEncounterGroup_GetAllAliveAIForWave_BP::Tag' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_GetAllAliveAIForWave_BP, ReturnValue) == 0x000008, "Member 'PhxAIEncounterGroup_GetAllAliveAIForWave_BP::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.GetNumAliveAI
// 0x0004 (0x0004 - 0x0000)
struct PhxAIEncounterGroup_GetNumAliveAI final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_GetNumAliveAI) == 0x000004, "Wrong alignment on PhxAIEncounterGroup_GetNumAliveAI");
static_assert(sizeof(PhxAIEncounterGroup_GetNumAliveAI) == 0x000004, "Wrong size on PhxAIEncounterGroup_GetNumAliveAI");
static_assert(offsetof(PhxAIEncounterGroup_GetNumAliveAI, ReturnValue) == 0x000000, "Member 'PhxAIEncounterGroup_GetNumAliveAI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.GetNumAliveAIForWave
// 0x000C (0x000C - 0x0000)
struct PhxAIEncounterGroup_GetNumAliveAIForWave final
{
public:
	class FName                                   Tag;                                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_GetNumAliveAIForWave) == 0x000004, "Wrong alignment on PhxAIEncounterGroup_GetNumAliveAIForWave");
static_assert(sizeof(PhxAIEncounterGroup_GetNumAliveAIForWave) == 0x00000C, "Wrong size on PhxAIEncounterGroup_GetNumAliveAIForWave");
static_assert(offsetof(PhxAIEncounterGroup_GetNumAliveAIForWave, Tag) == 0x000000, "Member 'PhxAIEncounterGroup_GetNumAliveAIForWave::Tag' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_GetNumAliveAIForWave, ReturnValue) == 0x000008, "Member 'PhxAIEncounterGroup_GetNumAliveAIForWave::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroup.GetWaveDescriptor
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroup_GetWaveDescriptor final
{
public:
	class FName                                   Tag;                                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIEncounterGroupWaveDescriptor*     ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroup_GetWaveDescriptor) == 0x000008, "Wrong alignment on PhxAIEncounterGroup_GetWaveDescriptor");
static_assert(sizeof(PhxAIEncounterGroup_GetWaveDescriptor) == 0x000010, "Wrong size on PhxAIEncounterGroup_GetWaveDescriptor");
static_assert(offsetof(PhxAIEncounterGroup_GetWaveDescriptor, Tag) == 0x000000, "Member 'PhxAIEncounterGroup_GetWaveDescriptor::Tag' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroup_GetWaveDescriptor, ReturnValue) == 0x000008, "Member 'PhxAIEncounterGroup_GetWaveDescriptor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIHordeEncounterGroup.GetAITypeAndCountForCurrentWave
// 0x0060 (0x0060 - 0x0000)
struct PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave final
{
public:
	int32                                         InHordeWaveIndex;                                  // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<struct FGameplayTag, int32>              OutAITypeAndCountMap;                              // 0x0008(0x0050)(Parm, OutParm, NativeAccessSpecifierPublic)
	int32                                         OutTotalAICountForWave;                            // 0x0058(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5C[0x4];                                       // 0x005C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave) == 0x000008, "Wrong alignment on PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave");
static_assert(sizeof(PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave) == 0x000060, "Wrong size on PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave");
static_assert(offsetof(PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave, InHordeWaveIndex) == 0x000000, "Member 'PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave::InHordeWaveIndex' has a wrong offset!");
static_assert(offsetof(PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave, OutAITypeAndCountMap) == 0x000008, "Member 'PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave::OutAITypeAndCountMap' has a wrong offset!");
static_assert(offsetof(PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave, OutTotalAICountForWave) == 0x000058, "Member 'PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave::OutTotalAICountForWave' has a wrong offset!");

// Function Phoenix.PhxAIHordeEncounterGroup.GetNumAIRemainingInActiveWave
// 0x0004 (0x0004 - 0x0000)
struct PhxAIHordeEncounterGroup_GetNumAIRemainingInActiveWave final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIHordeEncounterGroup_GetNumAIRemainingInActiveWave) == 0x000004, "Wrong alignment on PhxAIHordeEncounterGroup_GetNumAIRemainingInActiveWave");
static_assert(sizeof(PhxAIHordeEncounterGroup_GetNumAIRemainingInActiveWave) == 0x000004, "Wrong size on PhxAIHordeEncounterGroup_GetNumAIRemainingInActiveWave");
static_assert(offsetof(PhxAIHordeEncounterGroup_GetNumAIRemainingInActiveWave, ReturnValue) == 0x000000, "Member 'PhxAIHordeEncounterGroup_GetNumAIRemainingInActiveWave::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIHordeEncounterGroup.GetNumAIRemainingInWave
// 0x0008 (0x0008 - 0x0000)
struct PhxAIHordeEncounterGroup_GetNumAIRemainingInWave final
{
public:
	int32                                         WaveIndex;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIHordeEncounterGroup_GetNumAIRemainingInWave) == 0x000004, "Wrong alignment on PhxAIHordeEncounterGroup_GetNumAIRemainingInWave");
static_assert(sizeof(PhxAIHordeEncounterGroup_GetNumAIRemainingInWave) == 0x000008, "Wrong size on PhxAIHordeEncounterGroup_GetNumAIRemainingInWave");
static_assert(offsetof(PhxAIHordeEncounterGroup_GetNumAIRemainingInWave, WaveIndex) == 0x000000, "Member 'PhxAIHordeEncounterGroup_GetNumAIRemainingInWave::WaveIndex' has a wrong offset!");
static_assert(offsetof(PhxAIHordeEncounterGroup_GetNumAIRemainingInWave, ReturnValue) == 0x000004, "Member 'PhxAIHordeEncounterGroup_GetNumAIRemainingInWave::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIHordeEncounterGroup.KillAIByCount
// 0x0004 (0x0004 - 0x0000)
struct PhxAIHordeEncounterGroup_KillAIByCount final
{
public:
	int32                                         NumAIToKill;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIHordeEncounterGroup_KillAIByCount) == 0x000004, "Wrong alignment on PhxAIHordeEncounterGroup_KillAIByCount");
static_assert(sizeof(PhxAIHordeEncounterGroup_KillAIByCount) == 0x000004, "Wrong size on PhxAIHordeEncounterGroup_KillAIByCount");
static_assert(offsetof(PhxAIHordeEncounterGroup_KillAIByCount, NumAIToKill) == 0x000000, "Member 'PhxAIHordeEncounterGroup_KillAIByCount::NumAIToKill' has a wrong offset!");

// Function Phoenix.PhxAIHordeEncounterGroup.SetSafeRoomActive
// 0x0001 (0x0001 - 0x0000)
struct PhxAIHordeEncounterGroup_SetSafeRoomActive final
{
public:
	bool                                          bInSafeRoomActive;                                 // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIHordeEncounterGroup_SetSafeRoomActive) == 0x000001, "Wrong alignment on PhxAIHordeEncounterGroup_SetSafeRoomActive");
static_assert(sizeof(PhxAIHordeEncounterGroup_SetSafeRoomActive) == 0x000001, "Wrong size on PhxAIHordeEncounterGroup_SetSafeRoomActive");
static_assert(offsetof(PhxAIHordeEncounterGroup_SetSafeRoomActive, bInSafeRoomActive) == 0x000000, "Member 'PhxAIHordeEncounterGroup_SetSafeRoomActive::bInSafeRoomActive' has a wrong offset!");

// Function Phoenix.PhxAIHordeEncounterGroup.GetWaveSpawnDelay
// 0x0008 (0x0008 - 0x0000)
struct PhxAIHordeEncounterGroup_GetWaveSpawnDelay final
{
public:
	int32                                         InHordeWaveIndex;                                  // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIHordeEncounterGroup_GetWaveSpawnDelay) == 0x000004, "Wrong alignment on PhxAIHordeEncounterGroup_GetWaveSpawnDelay");
static_assert(sizeof(PhxAIHordeEncounterGroup_GetWaveSpawnDelay) == 0x000008, "Wrong size on PhxAIHordeEncounterGroup_GetWaveSpawnDelay");
static_assert(offsetof(PhxAIHordeEncounterGroup_GetWaveSpawnDelay, InHordeWaveIndex) == 0x000000, "Member 'PhxAIHordeEncounterGroup_GetWaveSpawnDelay::InHordeWaveIndex' has a wrong offset!");
static_assert(offsetof(PhxAIHordeEncounterGroup_GetWaveSpawnDelay, ReturnValue) == 0x000004, "Member 'PhxAIHordeEncounterGroup_GetWaveSpawnDelay::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSScreenWidget.SetBreadcrumb
// 0x0018 (0x0018 - 0x0000)
struct SDSScreenWidget_SetBreadcrumb final
{
public:
	class FText                                   InCrumb;                                           // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSScreenWidget_SetBreadcrumb) == 0x000008, "Wrong alignment on SDSScreenWidget_SetBreadcrumb");
static_assert(sizeof(SDSScreenWidget_SetBreadcrumb) == 0x000018, "Wrong size on SDSScreenWidget_SetBreadcrumb");
static_assert(offsetof(SDSScreenWidget_SetBreadcrumb, InCrumb) == 0x000000, "Member 'SDSScreenWidget_SetBreadcrumb::InCrumb' has a wrong offset!");

// Function Phoenix.SDSScreenWidget.SetSequenceScreen
// 0x0028 (0x0028 - 0x0000)
struct SDSScreenWidget_SetSequenceScreen final
{
public:
	TSoftClassPtr<class UClass>                   InSequenceScreen;                                  // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSScreenWidget_SetSequenceScreen) == 0x000008, "Wrong alignment on SDSScreenWidget_SetSequenceScreen");
static_assert(sizeof(SDSScreenWidget_SetSequenceScreen) == 0x000028, "Wrong size on SDSScreenWidget_SetSequenceScreen");
static_assert(offsetof(SDSScreenWidget_SetSequenceScreen, InSequenceScreen) == 0x000000, "Member 'SDSScreenWidget_SetSequenceScreen::InSequenceScreen' has a wrong offset!");

// Function Phoenix.SDSScreenWidget.SetUserUserParameter
// 0x0010 (0x0010 - 0x0000)
struct SDSScreenWidget_SetUserUserParameter final
{
public:
	class FString                                 InUserParameter;                                   // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSScreenWidget_SetUserUserParameter) == 0x000008, "Wrong alignment on SDSScreenWidget_SetUserUserParameter");
static_assert(sizeof(SDSScreenWidget_SetUserUserParameter) == 0x000010, "Wrong size on SDSScreenWidget_SetUserUserParameter");
static_assert(offsetof(SDSScreenWidget_SetUserUserParameter, InUserParameter) == 0x000000, "Member 'SDSScreenWidget_SetUserUserParameter::InUserParameter' has a wrong offset!");

// Function Phoenix.SDSMenuWidget.GetAdjacent
// 0x0018 (0x0018 - 0x0000)
struct SDSMenuWidget_GetAdjacent final
{
public:
	const class UPhxSelectable*                   Target;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0008(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxSelectable*                         ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSMenuWidget_GetAdjacent) == 0x000008, "Wrong alignment on SDSMenuWidget_GetAdjacent");
static_assert(sizeof(SDSMenuWidget_GetAdjacent) == 0x000018, "Wrong size on SDSMenuWidget_GetAdjacent");
static_assert(offsetof(SDSMenuWidget_GetAdjacent, Target) == 0x000000, "Member 'SDSMenuWidget_GetAdjacent::Target' has a wrong offset!");
static_assert(offsetof(SDSMenuWidget_GetAdjacent, Direction) == 0x000008, "Member 'SDSMenuWidget_GetAdjacent::Direction' has a wrong offset!");
static_assert(offsetof(SDSMenuWidget_GetAdjacent, ReturnValue) == 0x000010, "Member 'SDSMenuWidget_GetAdjacent::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSMenuWidget.PlayGlobalSound
// 0x0008 (0x0008 - 0x0000)
struct SDSMenuWidget_PlayGlobalSound final
{
public:
	const class UAkAudioEvent*                    Sound;                                             // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSMenuWidget_PlayGlobalSound) == 0x000008, "Wrong alignment on SDSMenuWidget_PlayGlobalSound");
static_assert(sizeof(SDSMenuWidget_PlayGlobalSound) == 0x000008, "Wrong size on SDSMenuWidget_PlayGlobalSound");
static_assert(offsetof(SDSMenuWidget_PlayGlobalSound, Sound) == 0x000000, "Member 'SDSMenuWidget_PlayGlobalSound::Sound' has a wrong offset!");

// Function Phoenix.SDSMenuWidget.UpdateSelected
// 0x0008 (0x0008 - 0x0000)
struct SDSMenuWidget_UpdateSelected final
{
public:
	class UPhxSelectable*                         Selected;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSMenuWidget_UpdateSelected) == 0x000008, "Wrong alignment on SDSMenuWidget_UpdateSelected");
static_assert(sizeof(SDSMenuWidget_UpdateSelected) == 0x000008, "Wrong size on SDSMenuWidget_UpdateSelected");
static_assert(offsetof(SDSMenuWidget_UpdateSelected, Selected) == 0x000000, "Member 'SDSMenuWidget_UpdateSelected::Selected' has a wrong offset!");

// Function Phoenix.SDSMenuWidget.GetSelected
// 0x0008 (0x0008 - 0x0000)
struct SDSMenuWidget_GetSelected final
{
public:
	class UPhxSelectable*                         ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSMenuWidget_GetSelected) == 0x000008, "Wrong alignment on SDSMenuWidget_GetSelected");
static_assert(sizeof(SDSMenuWidget_GetSelected) == 0x000008, "Wrong size on SDSMenuWidget_GetSelected");
static_assert(offsetof(SDSMenuWidget_GetSelected, ReturnValue) == 0x000000, "Member 'SDSMenuWidget_GetSelected::ReturnValue' has a wrong offset!");

// Function Phoenix.GammaScreenWidget.SetSliderPosition
// 0x0008 (0x0008 - 0x0000)
struct GammaScreenWidget_SetSliderPosition final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bBroadcast;                                        // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(GammaScreenWidget_SetSliderPosition) == 0x000004, "Wrong alignment on GammaScreenWidget_SetSliderPosition");
static_assert(sizeof(GammaScreenWidget_SetSliderPosition) == 0x000008, "Wrong size on GammaScreenWidget_SetSliderPosition");
static_assert(offsetof(GammaScreenWidget_SetSliderPosition, InValue) == 0x000000, "Member 'GammaScreenWidget_SetSliderPosition::InValue' has a wrong offset!");
static_assert(offsetof(GammaScreenWidget_SetSliderPosition, bBroadcast) == 0x000004, "Member 'GammaScreenWidget_SetSliderPosition::bBroadcast' has a wrong offset!");

// Function Phoenix.Pickup.CanPickup
// 0x0010 (0x0010 - 0x0000)
struct Pickup_CanPickup final
{
public:
	const class APhxCharacter*                    Picker;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(Pickup_CanPickup) == 0x000008, "Wrong alignment on Pickup_CanPickup");
static_assert(sizeof(Pickup_CanPickup) == 0x000010, "Wrong size on Pickup_CanPickup");
static_assert(offsetof(Pickup_CanPickup, Picker) == 0x000000, "Member 'Pickup_CanPickup::Picker' has a wrong offset!");
static_assert(offsetof(Pickup_CanPickup, ReturnValue) == 0x000008, "Member 'Pickup_CanPickup::ReturnValue' has a wrong offset!");

// Function Phoenix.Pickup.GetItemData
// 0x0100 (0x0100 - 0x0000)
struct Pickup_GetItemData final
{
public:
	struct FItemData                              ReturnValue;                                       // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(Pickup_GetItemData) == 0x000008, "Wrong alignment on Pickup_GetItemData");
static_assert(sizeof(Pickup_GetItemData) == 0x000100, "Wrong size on Pickup_GetItemData");
static_assert(offsetof(Pickup_GetItemData, ReturnValue) == 0x000000, "Member 'Pickup_GetItemData::ReturnValue' has a wrong offset!");

// Function Phoenix.Pickup.GetPickupSound
// 0x0008 (0x0008 - 0x0000)
struct Pickup_GetPickupSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Pickup_GetPickupSound) == 0x000008, "Wrong alignment on Pickup_GetPickupSound");
static_assert(sizeof(Pickup_GetPickupSound) == 0x000008, "Wrong size on Pickup_GetPickupSound");
static_assert(offsetof(Pickup_GetPickupSound, ReturnValue) == 0x000000, "Member 'Pickup_GetPickupSound::ReturnValue' has a wrong offset!");

// Function Phoenix.Pickup.GetVirtualItemData
// 0x0008 (0x0008 - 0x0000)
struct Pickup_GetVirtualItemData final
{
public:
	class UVirtualItemData*                       ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Pickup_GetVirtualItemData) == 0x000008, "Wrong alignment on Pickup_GetVirtualItemData");
static_assert(sizeof(Pickup_GetVirtualItemData) == 0x000008, "Wrong size on Pickup_GetVirtualItemData");
static_assert(offsetof(Pickup_GetVirtualItemData, ReturnValue) == 0x000000, "Member 'Pickup_GetVirtualItemData::ReturnValue' has a wrong offset!");

// Function Phoenix.Equippable.GetDiscardThenEquipAnimation
// 0x0008 (0x0008 - 0x0000)
struct Equippable_GetDiscardThenEquipAnimation final
{
public:
	class UAnimMontage*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Equippable_GetDiscardThenEquipAnimation) == 0x000008, "Wrong alignment on Equippable_GetDiscardThenEquipAnimation");
static_assert(sizeof(Equippable_GetDiscardThenEquipAnimation) == 0x000008, "Wrong size on Equippable_GetDiscardThenEquipAnimation");
static_assert(offsetof(Equippable_GetDiscardThenEquipAnimation, ReturnValue) == 0x000000, "Member 'Equippable_GetDiscardThenEquipAnimation::ReturnValue' has a wrong offset!");

// Function Phoenix.Equippable.OnEquipBegin
// 0x0001 (0x0001 - 0x0000)
struct Equippable_OnEquipBegin final
{
public:
	bool                                          bInstant;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Equippable_OnEquipBegin) == 0x000001, "Wrong alignment on Equippable_OnEquipBegin");
static_assert(sizeof(Equippable_OnEquipBegin) == 0x000001, "Wrong size on Equippable_OnEquipBegin");
static_assert(offsetof(Equippable_OnEquipBegin, bInstant) == 0x000000, "Member 'Equippable_OnEquipBegin::bInstant' has a wrong offset!");

// Function Phoenix.Equippable.OnUnequipBegin
// 0x0001 (0x0001 - 0x0000)
struct Equippable_OnUnequipBegin final
{
public:
	bool                                          bInstant;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Equippable_OnUnequipBegin) == 0x000001, "Wrong alignment on Equippable_OnUnequipBegin");
static_assert(sizeof(Equippable_OnUnequipBegin) == 0x000001, "Wrong size on Equippable_OnUnequipBegin");
static_assert(offsetof(Equippable_OnUnequipBegin, bInstant) == 0x000000, "Member 'Equippable_OnUnequipBegin::bInstant' has a wrong offset!");

// Function Phoenix.Equippable.GetEquipAnimation
// 0x0008 (0x0008 - 0x0000)
struct Equippable_GetEquipAnimation final
{
public:
	class UAnimMontage*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Equippable_GetEquipAnimation) == 0x000008, "Wrong alignment on Equippable_GetEquipAnimation");
static_assert(sizeof(Equippable_GetEquipAnimation) == 0x000008, "Wrong size on Equippable_GetEquipAnimation");
static_assert(offsetof(Equippable_GetEquipAnimation, ReturnValue) == 0x000000, "Member 'Equippable_GetEquipAnimation::ReturnValue' has a wrong offset!");

// Function Phoenix.Equippable.GetEquipSound
// 0x0008 (0x0008 - 0x0000)
struct Equippable_GetEquipSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Equippable_GetEquipSound) == 0x000008, "Wrong alignment on Equippable_GetEquipSound");
static_assert(sizeof(Equippable_GetEquipSound) == 0x000008, "Wrong size on Equippable_GetEquipSound");
static_assert(offsetof(Equippable_GetEquipSound, ReturnValue) == 0x000000, "Member 'Equippable_GetEquipSound::ReturnValue' has a wrong offset!");

// Function Phoenix.Equippable.GetHolsterAnimation
// 0x0008 (0x0008 - 0x0000)
struct Equippable_GetHolsterAnimation final
{
public:
	class UAnimMontage*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Equippable_GetHolsterAnimation) == 0x000008, "Wrong alignment on Equippable_GetHolsterAnimation");
static_assert(sizeof(Equippable_GetHolsterAnimation) == 0x000008, "Wrong size on Equippable_GetHolsterAnimation");
static_assert(offsetof(Equippable_GetHolsterAnimation, ReturnValue) == 0x000000, "Member 'Equippable_GetHolsterAnimation::ReturnValue' has a wrong offset!");

// Function Phoenix.Equippable.GetHolsterSound
// 0x0008 (0x0008 - 0x0000)
struct Equippable_GetHolsterSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Equippable_GetHolsterSound) == 0x000008, "Wrong alignment on Equippable_GetHolsterSound");
static_assert(sizeof(Equippable_GetHolsterSound) == 0x000008, "Wrong size on Equippable_GetHolsterSound");
static_assert(offsetof(Equippable_GetHolsterSound, ReturnValue) == 0x000000, "Member 'Equippable_GetHolsterSound::ReturnValue' has a wrong offset!");

// Function Phoenix.Equippable.GetMeshComponent
// 0x0008 (0x0008 - 0x0000)
struct Equippable_GetMeshComponent final
{
public:
	class UMeshComponent*                         ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Equippable_GetMeshComponent) == 0x000008, "Wrong alignment on Equippable_GetMeshComponent");
static_assert(sizeof(Equippable_GetMeshComponent) == 0x000008, "Wrong size on Equippable_GetMeshComponent");
static_assert(offsetof(Equippable_GetMeshComponent, ReturnValue) == 0x000000, "Member 'Equippable_GetMeshComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.Weapon.GetCurrentMaterialSlotsVisibility
// 0x0010 (0x0010 - 0x0000)
struct Weapon_GetCurrentMaterialSlotsVisibility final
{
public:
	TArray<bool>                                  OutSlotsVisibility;                                // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Weapon_GetCurrentMaterialSlotsVisibility) == 0x000008, "Wrong alignment on Weapon_GetCurrentMaterialSlotsVisibility");
static_assert(sizeof(Weapon_GetCurrentMaterialSlotsVisibility) == 0x000010, "Wrong size on Weapon_GetCurrentMaterialSlotsVisibility");
static_assert(offsetof(Weapon_GetCurrentMaterialSlotsVisibility, OutSlotsVisibility) == 0x000000, "Member 'Weapon_GetCurrentMaterialSlotsVisibility::OutSlotsVisibility' has a wrong offset!");

// Function Phoenix.Weapon.GetMaterialSlotsVisibilityWithUpgrades
// 0x0010 (0x0010 - 0x0000)
struct Weapon_GetMaterialSlotsVisibilityWithUpgrades final
{
public:
	TArray<bool>                                  OutSlotsVisibility;                                // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Weapon_GetMaterialSlotsVisibilityWithUpgrades) == 0x000008, "Wrong alignment on Weapon_GetMaterialSlotsVisibilityWithUpgrades");
static_assert(sizeof(Weapon_GetMaterialSlotsVisibilityWithUpgrades) == 0x000010, "Wrong size on Weapon_GetMaterialSlotsVisibilityWithUpgrades");
static_assert(offsetof(Weapon_GetMaterialSlotsVisibilityWithUpgrades, OutSlotsVisibility) == 0x000000, "Member 'Weapon_GetMaterialSlotsVisibilityWithUpgrades::OutSlotsVisibility' has a wrong offset!");

// Function Phoenix.Weapon.GetMeshComp
// 0x0008 (0x0008 - 0x0000)
struct Weapon_GetMeshComp final
{
public:
	class USkeletalMeshComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Weapon_GetMeshComp) == 0x000008, "Wrong alignment on Weapon_GetMeshComp");
static_assert(sizeof(Weapon_GetMeshComp) == 0x000008, "Wrong size on Weapon_GetMeshComp");
static_assert(offsetof(Weapon_GetMeshComp, ReturnValue) == 0x000000, "Member 'Weapon_GetMeshComp::ReturnValue' has a wrong offset!");

// Function Phoenix.Weapon.GetUpgradeComponent
// 0x0008 (0x0008 - 0x0000)
struct Weapon_GetUpgradeComponent final
{
public:
	class UPhxUpgradeComponent*                   ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Weapon_GetUpgradeComponent) == 0x000008, "Wrong alignment on Weapon_GetUpgradeComponent");
static_assert(sizeof(Weapon_GetUpgradeComponent) == 0x000008, "Wrong size on Weapon_GetUpgradeComponent");
static_assert(offsetof(Weapon_GetUpgradeComponent, ReturnValue) == 0x000000, "Member 'Weapon_GetUpgradeComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.Weapon.GetWeaponTag
// 0x0008 (0x0008 - 0x0000)
struct Weapon_GetWeaponTag final
{
public:
	struct FGameplayTag                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Weapon_GetWeaponTag) == 0x000004, "Wrong alignment on Weapon_GetWeaponTag");
static_assert(sizeof(Weapon_GetWeaponTag) == 0x000008, "Wrong size on Weapon_GetWeaponTag");
static_assert(offsetof(Weapon_GetWeaponTag, ReturnValue) == 0x000000, "Member 'Weapon_GetWeaponTag::ReturnValue' has a wrong offset!");

// Function Phoenix.MeleeWeapon.OnEquipTagRemoved
// 0x000C (0x000C - 0x0000)
struct MeleeWeapon_OnEquipTagRemoved final
{
public:
	struct FGameplayTag                           InTag;                                             // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NewCount;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MeleeWeapon_OnEquipTagRemoved) == 0x000004, "Wrong alignment on MeleeWeapon_OnEquipTagRemoved");
static_assert(sizeof(MeleeWeapon_OnEquipTagRemoved) == 0x00000C, "Wrong size on MeleeWeapon_OnEquipTagRemoved");
static_assert(offsetof(MeleeWeapon_OnEquipTagRemoved, InTag) == 0x000000, "Member 'MeleeWeapon_OnEquipTagRemoved::InTag' has a wrong offset!");
static_assert(offsetof(MeleeWeapon_OnEquipTagRemoved, NewCount) == 0x000008, "Member 'MeleeWeapon_OnEquipTagRemoved::NewCount' has a wrong offset!");

// Function Phoenix.MeleeWeapon.OnGroundSlamHit
// 0x000C (0x000C - 0x0000)
struct MeleeWeapon_OnGroundSlamHit final
{
public:
	struct FVector                                HitLocation;                                       // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MeleeWeapon_OnGroundSlamHit) == 0x000004, "Wrong alignment on MeleeWeapon_OnGroundSlamHit");
static_assert(sizeof(MeleeWeapon_OnGroundSlamHit) == 0x00000C, "Wrong size on MeleeWeapon_OnGroundSlamHit");
static_assert(offsetof(MeleeWeapon_OnGroundSlamHit, HitLocation) == 0x000000, "Member 'MeleeWeapon_OnGroundSlamHit::HitLocation' has a wrong offset!");

// Function Phoenix.MeleeWeapon.OnWeaponHit
// 0x0018 (0x0018 - 0x0000)
struct MeleeWeapon_OnWeaponHit final
{
public:
	const class AActor*                           HitActor;                                          // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ImpactLocation;                                    // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsChargedAttack;                                  // 0x0014(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsHeavyAttack;                                    // 0x0015(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDisableImpactFX;                                  // 0x0016(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_17[0x1];                                       // 0x0017(0x0001)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(MeleeWeapon_OnWeaponHit) == 0x000008, "Wrong alignment on MeleeWeapon_OnWeaponHit");
static_assert(sizeof(MeleeWeapon_OnWeaponHit) == 0x000018, "Wrong size on MeleeWeapon_OnWeaponHit");
static_assert(offsetof(MeleeWeapon_OnWeaponHit, HitActor) == 0x000000, "Member 'MeleeWeapon_OnWeaponHit::HitActor' has a wrong offset!");
static_assert(offsetof(MeleeWeapon_OnWeaponHit, ImpactLocation) == 0x000008, "Member 'MeleeWeapon_OnWeaponHit::ImpactLocation' has a wrong offset!");
static_assert(offsetof(MeleeWeapon_OnWeaponHit, bIsChargedAttack) == 0x000014, "Member 'MeleeWeapon_OnWeaponHit::bIsChargedAttack' has a wrong offset!");
static_assert(offsetof(MeleeWeapon_OnWeaponHit, bIsHeavyAttack) == 0x000015, "Member 'MeleeWeapon_OnWeaponHit::bIsHeavyAttack' has a wrong offset!");
static_assert(offsetof(MeleeWeapon_OnWeaponHit, bDisableImpactFX) == 0x000016, "Member 'MeleeWeapon_OnWeaponHit::bDisableImpactFX' has a wrong offset!");

// Function Phoenix.MeleeAttackState.OnTargetDefensiveReactionInputEnded
// 0x0002 (0x0002 - 0x0000)
struct MeleeAttackState_OnTargetDefensiveReactionInputEnded final
{
public:
	EReactionType                                 ReactionType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefensiveReactDirection                      ReactionDir;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MeleeAttackState_OnTargetDefensiveReactionInputEnded) == 0x000001, "Wrong alignment on MeleeAttackState_OnTargetDefensiveReactionInputEnded");
static_assert(sizeof(MeleeAttackState_OnTargetDefensiveReactionInputEnded) == 0x000002, "Wrong size on MeleeAttackState_OnTargetDefensiveReactionInputEnded");
static_assert(offsetof(MeleeAttackState_OnTargetDefensiveReactionInputEnded, ReactionType) == 0x000000, "Member 'MeleeAttackState_OnTargetDefensiveReactionInputEnded::ReactionType' has a wrong offset!");
static_assert(offsetof(MeleeAttackState_OnTargetDefensiveReactionInputEnded, ReactionDir) == 0x000001, "Member 'MeleeAttackState_OnTargetDefensiveReactionInputEnded::ReactionDir' has a wrong offset!");

// Function Phoenix.MeleeAttackState.OnTargetDefensiveReactionInputStarted
// 0x0002 (0x0002 - 0x0000)
struct MeleeAttackState_OnTargetDefensiveReactionInputStarted final
{
public:
	EReactionType                                 ReactionType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefensiveReactDirection                      ReactionDir;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MeleeAttackState_OnTargetDefensiveReactionInputStarted) == 0x000001, "Wrong alignment on MeleeAttackState_OnTargetDefensiveReactionInputStarted");
static_assert(sizeof(MeleeAttackState_OnTargetDefensiveReactionInputStarted) == 0x000002, "Wrong size on MeleeAttackState_OnTargetDefensiveReactionInputStarted");
static_assert(offsetof(MeleeAttackState_OnTargetDefensiveReactionInputStarted, ReactionType) == 0x000000, "Member 'MeleeAttackState_OnTargetDefensiveReactionInputStarted::ReactionType' has a wrong offset!");
static_assert(offsetof(MeleeAttackState_OnTargetDefensiveReactionInputStarted, ReactionDir) == 0x000001, "Member 'MeleeAttackState_OnTargetDefensiveReactionInputStarted::ReactionDir' has a wrong offset!");

// Function Phoenix.BloodwormParryState.ReceiveQteCompletion
// 0x000C (0x000C - 0x0000)
struct BloodwormParryState_ReceiveQteCompletion final
{
public:
	class FName                                   InQteId;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInResult;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(BloodwormParryState_ReceiveQteCompletion) == 0x000004, "Wrong alignment on BloodwormParryState_ReceiveQteCompletion");
static_assert(sizeof(BloodwormParryState_ReceiveQteCompletion) == 0x00000C, "Wrong size on BloodwormParryState_ReceiveQteCompletion");
static_assert(offsetof(BloodwormParryState_ReceiveQteCompletion, InQteId) == 0x000000, "Member 'BloodwormParryState_ReceiveQteCompletion::InQteId' has a wrong offset!");
static_assert(offsetof(BloodwormParryState_ReceiveQteCompletion, bInResult) == 0x000008, "Member 'BloodwormParryState_ReceiveQteCompletion::bInResult' has a wrong offset!");

// Function Phoenix.GlowBlob.OnPerceived
// 0x0048 (0x0048 - 0x0000)
struct GlowBlob_OnPerceived final
{
public:
	class AActor*                                 Actor;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FAIStimulus                            Stimulus;                                          // 0x0008(0x003C)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(GlowBlob_OnPerceived) == 0x000008, "Wrong alignment on GlowBlob_OnPerceived");
static_assert(sizeof(GlowBlob_OnPerceived) == 0x000048, "Wrong size on GlowBlob_OnPerceived");
static_assert(offsetof(GlowBlob_OnPerceived, Actor) == 0x000000, "Member 'GlowBlob_OnPerceived::Actor' has a wrong offset!");
static_assert(offsetof(GlowBlob_OnPerceived, Stimulus) == 0x000008, "Member 'GlowBlob_OnPerceived::Stimulus' has a wrong offset!");

// Function Phoenix.EnvironmentalHazard.BP_OnTriggered
// 0x0098 (0x0098 - 0x0000)
struct EnvironmentalHazard_BP_OnTriggered final
{
public:
	class APhxCharacter*                          EnemyCharacter;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             OverlapResult;                                     // 0x0010(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(EnvironmentalHazard_BP_OnTriggered) == 0x000008, "Wrong alignment on EnvironmentalHazard_BP_OnTriggered");
static_assert(sizeof(EnvironmentalHazard_BP_OnTriggered) == 0x000098, "Wrong size on EnvironmentalHazard_BP_OnTriggered");
static_assert(offsetof(EnvironmentalHazard_BP_OnTriggered, EnemyCharacter) == 0x000000, "Member 'EnvironmentalHazard_BP_OnTriggered::EnemyCharacter' has a wrong offset!");
static_assert(offsetof(EnvironmentalHazard_BP_OnTriggered, OverlappedComponent) == 0x000008, "Member 'EnvironmentalHazard_BP_OnTriggered::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(EnvironmentalHazard_BP_OnTriggered, OverlapResult) == 0x000010, "Member 'EnvironmentalHazard_BP_OnTriggered::OverlapResult' has a wrong offset!");

// Function Phoenix.EnvironmentalHazard.OnOverlapDetected
// 0x00A8 (0x00A8 - 0x0000)
struct EnvironmentalHazard_OnOverlapDetected final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(EnvironmentalHazard_OnOverlapDetected) == 0x000008, "Wrong alignment on EnvironmentalHazard_OnOverlapDetected");
static_assert(sizeof(EnvironmentalHazard_OnOverlapDetected) == 0x0000A8, "Wrong size on EnvironmentalHazard_OnOverlapDetected");
static_assert(offsetof(EnvironmentalHazard_OnOverlapDetected, OverlappedComponent) == 0x000000, "Member 'EnvironmentalHazard_OnOverlapDetected::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(EnvironmentalHazard_OnOverlapDetected, OtherActor) == 0x000008, "Member 'EnvironmentalHazard_OnOverlapDetected::OtherActor' has a wrong offset!");
static_assert(offsetof(EnvironmentalHazard_OnOverlapDetected, OtherComp) == 0x000010, "Member 'EnvironmentalHazard_OnOverlapDetected::OtherComp' has a wrong offset!");
static_assert(offsetof(EnvironmentalHazard_OnOverlapDetected, OtherBodyIndex) == 0x000018, "Member 'EnvironmentalHazard_OnOverlapDetected::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(EnvironmentalHazard_OnOverlapDetected, bFromSweep) == 0x00001C, "Member 'EnvironmentalHazard_OnOverlapDetected::bFromSweep' has a wrong offset!");
static_assert(offsetof(EnvironmentalHazard_OnOverlapDetected, SweepResult) == 0x000020, "Member 'EnvironmentalHazard_OnOverlapDetected::SweepResult' has a wrong offset!");

// Function Phoenix.EnvironmentalHazard.SetActive
// 0x0001 (0x0001 - 0x0000)
struct EnvironmentalHazard_SetActive final
{
public:
	bool                                          bOn;                                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EnvironmentalHazard_SetActive) == 0x000001, "Wrong alignment on EnvironmentalHazard_SetActive");
static_assert(sizeof(EnvironmentalHazard_SetActive) == 0x000001, "Wrong size on EnvironmentalHazard_SetActive");
static_assert(offsetof(EnvironmentalHazard_SetActive, bOn) == 0x000000, "Member 'EnvironmentalHazard_SetActive::bOn' has a wrong offset!");

// Function Phoenix.EnvironmentalHazard.IsSwitchedOn
// 0x0001 (0x0001 - 0x0000)
struct EnvironmentalHazard_IsSwitchedOn final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EnvironmentalHazard_IsSwitchedOn) == 0x000001, "Wrong alignment on EnvironmentalHazard_IsSwitchedOn");
static_assert(sizeof(EnvironmentalHazard_IsSwitchedOn) == 0x000001, "Wrong size on EnvironmentalHazard_IsSwitchedOn");
static_assert(offsetof(EnvironmentalHazard_IsSwitchedOn, ReturnValue) == 0x000000, "Member 'EnvironmentalHazard_IsSwitchedOn::ReturnValue' has a wrong offset!");

// Function Phoenix.EnvironmentalHazard_SpikeWall.GetWallCollisionBoxExtent
// 0x000C (0x000C - 0x0000)
struct EnvironmentalHazard_SpikeWall_GetWallCollisionBoxExtent final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EnvironmentalHazard_SpikeWall_GetWallCollisionBoxExtent) == 0x000004, "Wrong alignment on EnvironmentalHazard_SpikeWall_GetWallCollisionBoxExtent");
static_assert(sizeof(EnvironmentalHazard_SpikeWall_GetWallCollisionBoxExtent) == 0x00000C, "Wrong size on EnvironmentalHazard_SpikeWall_GetWallCollisionBoxExtent");
static_assert(offsetof(EnvironmentalHazard_SpikeWall_GetWallCollisionBoxExtent, ReturnValue) == 0x000000, "Member 'EnvironmentalHazard_SpikeWall_GetWallCollisionBoxExtent::ReturnValue' has a wrong offset!");

// Function Phoenix.EnvironmentalHazard_SpikeWall.GetWallCollisionComponentLocation
// 0x000C (0x000C - 0x0000)
struct EnvironmentalHazard_SpikeWall_GetWallCollisionComponentLocation final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EnvironmentalHazard_SpikeWall_GetWallCollisionComponentLocation) == 0x000004, "Wrong alignment on EnvironmentalHazard_SpikeWall_GetWallCollisionComponentLocation");
static_assert(sizeof(EnvironmentalHazard_SpikeWall_GetWallCollisionComponentLocation) == 0x00000C, "Wrong size on EnvironmentalHazard_SpikeWall_GetWallCollisionComponentLocation");
static_assert(offsetof(EnvironmentalHazard_SpikeWall_GetWallCollisionComponentLocation, ReturnValue) == 0x000000, "Member 'EnvironmentalHazard_SpikeWall_GetWallCollisionComponentLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.EnvironmentalHazard_SpikeWall.GetWallSpikeForward
// 0x000C (0x000C - 0x0000)
struct EnvironmentalHazard_SpikeWall_GetWallSpikeForward final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EnvironmentalHazard_SpikeWall_GetWallSpikeForward) == 0x000004, "Wrong alignment on EnvironmentalHazard_SpikeWall_GetWallSpikeForward");
static_assert(sizeof(EnvironmentalHazard_SpikeWall_GetWallSpikeForward) == 0x00000C, "Wrong size on EnvironmentalHazard_SpikeWall_GetWallSpikeForward");
static_assert(offsetof(EnvironmentalHazard_SpikeWall_GetWallSpikeForward, ReturnValue) == 0x000000, "Member 'EnvironmentalHazard_SpikeWall_GetWallSpikeForward::ReturnValue' has a wrong offset!");

// Function Phoenix.EnvironmentalHazard_SpikeWall.GetWallSpikeRight
// 0x000C (0x000C - 0x0000)
struct EnvironmentalHazard_SpikeWall_GetWallSpikeRight final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EnvironmentalHazard_SpikeWall_GetWallSpikeRight) == 0x000004, "Wrong alignment on EnvironmentalHazard_SpikeWall_GetWallSpikeRight");
static_assert(sizeof(EnvironmentalHazard_SpikeWall_GetWallSpikeRight) == 0x00000C, "Wrong size on EnvironmentalHazard_SpikeWall_GetWallSpikeRight");
static_assert(offsetof(EnvironmentalHazard_SpikeWall_GetWallSpikeRight, ReturnValue) == 0x000000, "Member 'EnvironmentalHazard_SpikeWall_GetWallSpikeRight::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMenuWidget.GetWidgetMenuButtons
// 0x0010 (0x0010 - 0x0000)
struct PhxMenuWidget_GetWidgetMenuButtons final
{
public:
	TArray<class UMenuButton*>                    ReturnValue;                                       // 0x0000(0x0010)(ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMenuWidget_GetWidgetMenuButtons) == 0x000008, "Wrong alignment on PhxMenuWidget_GetWidgetMenuButtons");
static_assert(sizeof(PhxMenuWidget_GetWidgetMenuButtons) == 0x000010, "Wrong size on PhxMenuWidget_GetWidgetMenuButtons");
static_assert(offsetof(PhxMenuWidget_GetWidgetMenuButtons, ReturnValue) == 0x000000, "Member 'PhxMenuWidget_GetWidgetMenuButtons::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIProp.TryTrigger
// 0x0018 (0x0018 - 0x0000)
struct PhxAIProp_TryTrigger final
{
public:
	class AActor*                                 Triggerer;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           TriggerType;                                       // 0x0008(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIProp_TryTrigger) == 0x000008, "Wrong alignment on PhxAIProp_TryTrigger");
static_assert(sizeof(PhxAIProp_TryTrigger) == 0x000018, "Wrong size on PhxAIProp_TryTrigger");
static_assert(offsetof(PhxAIProp_TryTrigger, Triggerer) == 0x000000, "Member 'PhxAIProp_TryTrigger::Triggerer' has a wrong offset!");
static_assert(offsetof(PhxAIProp_TryTrigger, TriggerType) == 0x000008, "Member 'PhxAIProp_TryTrigger::TriggerType' has a wrong offset!");
static_assert(offsetof(PhxAIProp_TryTrigger, ReturnValue) == 0x000010, "Member 'PhxAIProp_TryTrigger::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIProp.GetTriggerType
// 0x0018 (0x0018 - 0x0000)
struct PhxAIProp_GetTriggerType final
{
public:
	class AActor*                                 Triggerer;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           TriggerType;                                       // 0x0008(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIProp_GetTriggerType) == 0x000008, "Wrong alignment on PhxAIProp_GetTriggerType");
static_assert(sizeof(PhxAIProp_GetTriggerType) == 0x000018, "Wrong size on PhxAIProp_GetTriggerType");
static_assert(offsetof(PhxAIProp_GetTriggerType, Triggerer) == 0x000000, "Member 'PhxAIProp_GetTriggerType::Triggerer' has a wrong offset!");
static_assert(offsetof(PhxAIProp_GetTriggerType, TriggerType) == 0x000008, "Member 'PhxAIProp_GetTriggerType::TriggerType' has a wrong offset!");
static_assert(offsetof(PhxAIProp_GetTriggerType, ReturnValue) == 0x000010, "Member 'PhxAIProp_GetTriggerType::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAnnouncer.PlayAnnouncementOverhead
// 0x0010 (0x0010 - 0x0000)
struct PhxAnnouncer_PlayAnnouncementOverhead final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkAudioEvent*                          Event;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAnnouncer_PlayAnnouncementOverhead) == 0x000008, "Wrong alignment on PhxAnnouncer_PlayAnnouncementOverhead");
static_assert(sizeof(PhxAnnouncer_PlayAnnouncementOverhead) == 0x000010, "Wrong size on PhxAnnouncer_PlayAnnouncementOverhead");
static_assert(offsetof(PhxAnnouncer_PlayAnnouncementOverhead, WorldContextObject) == 0x000000, "Member 'PhxAnnouncer_PlayAnnouncementOverhead::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAnnouncer_PlayAnnouncementOverhead, Event) == 0x000008, "Member 'PhxAnnouncer_PlayAnnouncementOverhead::Event' has a wrong offset!");

// Function Phoenix.PlayerControllerState.GetCharacter
// 0x0008 (0x0008 - 0x0000)
struct PlayerControllerState_GetCharacter final
{
public:
	class APhxPlayerCharacter*                    ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PlayerControllerState_GetCharacter) == 0x000008, "Wrong alignment on PlayerControllerState_GetCharacter");
static_assert(sizeof(PlayerControllerState_GetCharacter) == 0x000008, "Wrong size on PlayerControllerState_GetCharacter");
static_assert(offsetof(PlayerControllerState_GetCharacter, ReturnValue) == 0x000000, "Member 'PlayerControllerState_GetCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryMainStateBase.HandleGameplayTagCallback
// 0x000C (0x000C - 0x0000)
struct InventoryMainStateBase_HandleGameplayTagCallback final
{
public:
	struct FGameplayTag                           InTag;                                             // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NewCount;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryMainStateBase_HandleGameplayTagCallback) == 0x000004, "Wrong alignment on InventoryMainStateBase_HandleGameplayTagCallback");
static_assert(sizeof(InventoryMainStateBase_HandleGameplayTagCallback) == 0x00000C, "Wrong size on InventoryMainStateBase_HandleGameplayTagCallback");
static_assert(offsetof(InventoryMainStateBase_HandleGameplayTagCallback, InTag) == 0x000000, "Member 'InventoryMainStateBase_HandleGameplayTagCallback::InTag' has a wrong offset!");
static_assert(offsetof(InventoryMainStateBase_HandleGameplayTagCallback, NewCount) == 0x000008, "Member 'InventoryMainStateBase_HandleGameplayTagCallback::NewCount' has a wrong offset!");

// Function Phoenix.Interaction.GetHighestPriorityInteraction
// 0x0018 (0x0018 - 0x0000)
struct Interaction_GetHighestPriorityInteraction final
{
public:
	TArray<TSubclassOf<class UInteraction>>       Interactions;                                      // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
	TSubclassOf<class UInteraction>               ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Interaction_GetHighestPriorityInteraction) == 0x000008, "Wrong alignment on Interaction_GetHighestPriorityInteraction");
static_assert(sizeof(Interaction_GetHighestPriorityInteraction) == 0x000018, "Wrong size on Interaction_GetHighestPriorityInteraction");
static_assert(offsetof(Interaction_GetHighestPriorityInteraction, Interactions) == 0x000000, "Member 'Interaction_GetHighestPriorityInteraction::Interactions' has a wrong offset!");
static_assert(offsetof(Interaction_GetHighestPriorityInteraction, ReturnValue) == 0x000010, "Member 'Interaction_GetHighestPriorityInteraction::ReturnValue' has a wrong offset!");

// Function Phoenix.Interaction.Intersects
// 0x0038 (0x0038 - 0x0000)
struct Interaction_Intersects final
{
public:
	TArray<TSubclassOf<class UInteraction>>       A;                                                 // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<TSubclassOf<class UInteraction>>       B;                                                 // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<TSubclassOf<class UInteraction>>       Intersection;                                      // 0x0020(0x0010)(Parm, OutParm, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0030(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(Interaction_Intersects) == 0x000008, "Wrong alignment on Interaction_Intersects");
static_assert(sizeof(Interaction_Intersects) == 0x000038, "Wrong size on Interaction_Intersects");
static_assert(offsetof(Interaction_Intersects, A) == 0x000000, "Member 'Interaction_Intersects::A' has a wrong offset!");
static_assert(offsetof(Interaction_Intersects, B) == 0x000010, "Member 'Interaction_Intersects::B' has a wrong offset!");
static_assert(offsetof(Interaction_Intersects, Intersection) == 0x000020, "Member 'Interaction_Intersects::Intersection' has a wrong offset!");
static_assert(offsetof(Interaction_Intersects, ReturnValue) == 0x000030, "Member 'Interaction_Intersects::ReturnValue' has a wrong offset!");

// Function Phoenix.Interaction.Initialize
// 0x0010 (0x0010 - 0x0000)
struct Interaction_Initialize final
{
public:
	class APawn*                                  NewSource;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UInteractableComponent*                 NewTarget;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Interaction_Initialize) == 0x000008, "Wrong alignment on Interaction_Initialize");
static_assert(sizeof(Interaction_Initialize) == 0x000010, "Wrong size on Interaction_Initialize");
static_assert(offsetof(Interaction_Initialize, NewSource) == 0x000000, "Member 'Interaction_Initialize::NewSource' has a wrong offset!");
static_assert(offsetof(Interaction_Initialize, NewTarget) == 0x000008, "Member 'Interaction_Initialize::NewTarget' has a wrong offset!");

// Function Phoenix.Interaction.GetSource
// 0x0008 (0x0008 - 0x0000)
struct Interaction_GetSource final
{
public:
	class APawn*                                  ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Interaction_GetSource) == 0x000008, "Wrong alignment on Interaction_GetSource");
static_assert(sizeof(Interaction_GetSource) == 0x000008, "Wrong size on Interaction_GetSource");
static_assert(offsetof(Interaction_GetSource, ReturnValue) == 0x000000, "Member 'Interaction_GetSource::ReturnValue' has a wrong offset!");

// Function Phoenix.Interaction.GetSourceToTargetTransformation
// 0x0030 (0x0030 - 0x0000)
struct Interaction_GetSourceToTargetTransformation final
{
public:
	struct FTransform                             ReturnValue;                                       // 0x0000(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Interaction_GetSourceToTargetTransformation) == 0x000010, "Wrong alignment on Interaction_GetSourceToTargetTransformation");
static_assert(sizeof(Interaction_GetSourceToTargetTransformation) == 0x000030, "Wrong size on Interaction_GetSourceToTargetTransformation");
static_assert(offsetof(Interaction_GetSourceToTargetTransformation, ReturnValue) == 0x000000, "Member 'Interaction_GetSourceToTargetTransformation::ReturnValue' has a wrong offset!");

// Function Phoenix.Interaction.GetSourceTransform
// 0x0030 (0x0030 - 0x0000)
struct Interaction_GetSourceTransform final
{
public:
	struct FTransform                             ReturnValue;                                       // 0x0000(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Interaction_GetSourceTransform) == 0x000010, "Wrong alignment on Interaction_GetSourceTransform");
static_assert(sizeof(Interaction_GetSourceTransform) == 0x000030, "Wrong size on Interaction_GetSourceTransform");
static_assert(offsetof(Interaction_GetSourceTransform, ReturnValue) == 0x000000, "Member 'Interaction_GetSourceTransform::ReturnValue' has a wrong offset!");

// Function Phoenix.Interaction.GetTarget
// 0x0008 (0x0008 - 0x0000)
struct Interaction_GetTarget final
{
public:
	class UInteractableComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Interaction_GetTarget) == 0x000008, "Wrong alignment on Interaction_GetTarget");
static_assert(sizeof(Interaction_GetTarget) == 0x000008, "Wrong size on Interaction_GetTarget");
static_assert(offsetof(Interaction_GetTarget, ReturnValue) == 0x000000, "Member 'Interaction_GetTarget::ReturnValue' has a wrong offset!");

// Function Phoenix.Interaction.GetTargetActorTransform
// 0x0030 (0x0030 - 0x0000)
struct Interaction_GetTargetActorTransform final
{
public:
	struct FTransform                             ReturnValue;                                       // 0x0000(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Interaction_GetTargetActorTransform) == 0x000010, "Wrong alignment on Interaction_GetTargetActorTransform");
static_assert(sizeof(Interaction_GetTargetActorTransform) == 0x000030, "Wrong size on Interaction_GetTargetActorTransform");
static_assert(offsetof(Interaction_GetTargetActorTransform, ReturnValue) == 0x000000, "Member 'Interaction_GetTargetActorTransform::ReturnValue' has a wrong offset!");

// Function Phoenix.Interaction.GetTargetTransform
// 0x0030 (0x0030 - 0x0000)
struct Interaction_GetTargetTransform final
{
public:
	struct FTransform                             ReturnValue;                                       // 0x0000(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Interaction_GetTargetTransform) == 0x000010, "Wrong alignment on Interaction_GetTargetTransform");
static_assert(sizeof(Interaction_GetTargetTransform) == 0x000030, "Wrong size on Interaction_GetTargetTransform");
static_assert(offsetof(Interaction_GetTargetTransform, ReturnValue) == 0x000000, "Member 'Interaction_GetTargetTransform::ReturnValue' has a wrong offset!");

// Function Phoenix.TrackFollower.GetCurrentSplineLocation
// 0x0004 (0x0004 - 0x0000)
struct TrackFollower_GetCurrentSplineLocation final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TrackFollower_GetCurrentSplineLocation) == 0x000004, "Wrong alignment on TrackFollower_GetCurrentSplineLocation");
static_assert(sizeof(TrackFollower_GetCurrentSplineLocation) == 0x000004, "Wrong size on TrackFollower_GetCurrentSplineLocation");
static_assert(offsetof(TrackFollower_GetCurrentSplineLocation, ReturnValue) == 0x000000, "Member 'TrackFollower_GetCurrentSplineLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.InventorySlot.ApplyVID
// 0x0008 (0x0008 - 0x0000)
struct InventorySlot_ApplyVID final
{
public:
	const class UVirtualItemData*                 InVID;                                             // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventorySlot_ApplyVID) == 0x000008, "Wrong alignment on InventorySlot_ApplyVID");
static_assert(sizeof(InventorySlot_ApplyVID) == 0x000008, "Wrong size on InventorySlot_ApplyVID");
static_assert(offsetof(InventorySlot_ApplyVID, InVID) == 0x000000, "Member 'InventorySlot_ApplyVID::InVID' has a wrong offset!");

// Function Phoenix.InventorySlot.NotifyConfirmHeld
// 0x0004 (0x0004 - 0x0000)
struct InventorySlot_NotifyConfirmHeld final
{
public:
	float                                         TimeHeld;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventorySlot_NotifyConfirmHeld) == 0x000004, "Wrong alignment on InventorySlot_NotifyConfirmHeld");
static_assert(sizeof(InventorySlot_NotifyConfirmHeld) == 0x000004, "Wrong size on InventorySlot_NotifyConfirmHeld");
static_assert(offsetof(InventorySlot_NotifyConfirmHeld, TimeHeld) == 0x000000, "Member 'InventorySlot_NotifyConfirmHeld::TimeHeld' has a wrong offset!");

// Function Phoenix.InventorySlot.SetItem
// 0x0100 (0x0100 - 0x0000)
struct InventorySlot_SetItem final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventorySlot_SetItem) == 0x000008, "Wrong alignment on InventorySlot_SetItem");
static_assert(sizeof(InventorySlot_SetItem) == 0x000100, "Wrong size on InventorySlot_SetItem");
static_assert(offsetof(InventorySlot_SetItem, InItem) == 0x000000, "Member 'InventorySlot_SetItem::InItem' has a wrong offset!");

// Function Phoenix.InventorySlot.GetCachedItemData
// 0x0100 (0x0100 - 0x0000)
struct InventorySlot_GetCachedItemData final
{
public:
	struct FItemData                              ReturnValue;                                       // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventorySlot_GetCachedItemData) == 0x000008, "Wrong alignment on InventorySlot_GetCachedItemData");
static_assert(sizeof(InventorySlot_GetCachedItemData) == 0x000100, "Wrong size on InventorySlot_GetCachedItemData");
static_assert(offsetof(InventorySlot_GetCachedItemData, ReturnValue) == 0x000000, "Member 'InventorySlot_GetCachedItemData::ReturnValue' has a wrong offset!");

// Function Phoenix.InventorySlot.IsBreadcrumbActive
// 0x0001 (0x0001 - 0x0000)
struct InventorySlot_IsBreadcrumbActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventorySlot_IsBreadcrumbActive) == 0x000001, "Wrong alignment on InventorySlot_IsBreadcrumbActive");
static_assert(sizeof(InventorySlot_IsBreadcrumbActive) == 0x000001, "Wrong size on InventorySlot_IsBreadcrumbActive");
static_assert(offsetof(InventorySlot_IsBreadcrumbActive, ReturnValue) == 0x000000, "Member 'InventorySlot_IsBreadcrumbActive::ReturnValue' has a wrong offset!");

// Function Phoenix.InventorySlot.IsNavigationBlocked
// 0x0001 (0x0001 - 0x0000)
struct InventorySlot_IsNavigationBlocked final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventorySlot_IsNavigationBlocked) == 0x000001, "Wrong alignment on InventorySlot_IsNavigationBlocked");
static_assert(sizeof(InventorySlot_IsNavigationBlocked) == 0x000001, "Wrong size on InventorySlot_IsNavigationBlocked");
static_assert(offsetof(InventorySlot_IsNavigationBlocked, ReturnValue) == 0x000000, "Member 'InventorySlot_IsNavigationBlocked::ReturnValue' has a wrong offset!");

// Function Phoenix.InventorySlot.IsOccupied
// 0x0001 (0x0001 - 0x0000)
struct InventorySlot_IsOccupied final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventorySlot_IsOccupied) == 0x000001, "Wrong alignment on InventorySlot_IsOccupied");
static_assert(sizeof(InventorySlot_IsOccupied) == 0x000001, "Wrong size on InventorySlot_IsOccupied");
static_assert(offsetof(InventorySlot_IsOccupied, ReturnValue) == 0x000000, "Member 'InventorySlot_IsOccupied::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility.EndAbility_Internal
// 0x0002 (0x0002 - 0x0000)
struct PhxGameplayAbility_EndAbility_Internal final
{
public:
	bool                                          bRemoveAbility;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCancel;                                           // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_EndAbility_Internal) == 0x000001, "Wrong alignment on PhxGameplayAbility_EndAbility_Internal");
static_assert(sizeof(PhxGameplayAbility_EndAbility_Internal) == 0x000002, "Wrong size on PhxGameplayAbility_EndAbility_Internal");
static_assert(offsetof(PhxGameplayAbility_EndAbility_Internal, bRemoveAbility) == 0x000000, "Member 'PhxGameplayAbility_EndAbility_Internal::bRemoveAbility' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_EndAbility_Internal, bCancel) == 0x000001, "Member 'PhxGameplayAbility_EndAbility_Internal::bCancel' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility.IsTaskActive
// 0x000C (0x000C - 0x0000)
struct PhxGameplayAbility_IsTaskActive final
{
public:
	class FName                                   TaskInstanceName;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayAbility_IsTaskActive) == 0x000004, "Wrong alignment on PhxGameplayAbility_IsTaskActive");
static_assert(sizeof(PhxGameplayAbility_IsTaskActive) == 0x00000C, "Wrong size on PhxGameplayAbility_IsTaskActive");
static_assert(offsetof(PhxGameplayAbility_IsTaskActive, TaskInstanceName) == 0x000000, "Member 'PhxGameplayAbility_IsTaskActive::TaskInstanceName' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_IsTaskActive, ReturnValue) == 0x000008, "Member 'PhxGameplayAbility_IsTaskActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_Parasite_Leap.OnEnemyHit
// 0x00B0 (0x00B0 - 0x0000)
struct PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit");
static_assert(sizeof(PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit) == 0x0000B0, "Wrong size on PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit");
static_assert(offsetof(PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit, HitComp) == 0x000000, "Member 'PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit::HitComp' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit, OtherActor) == 0x000008, "Member 'PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit, OtherComp) == 0x000010, "Member 'PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit, NormalImpulse) == 0x000018, "Member 'PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit, Hit) == 0x000024, "Member 'PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit::Hit' has a wrong offset!");

// Function Phoenix.GlowManager.OnPerceived
// 0x0048 (0x0048 - 0x0000)
struct GlowManager_OnPerceived final
{
public:
	class AActor*                                 Actor;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FAIStimulus                            Stimulus;                                          // 0x0008(0x003C)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(GlowManager_OnPerceived) == 0x000008, "Wrong alignment on GlowManager_OnPerceived");
static_assert(sizeof(GlowManager_OnPerceived) == 0x000048, "Wrong size on GlowManager_OnPerceived");
static_assert(offsetof(GlowManager_OnPerceived, Actor) == 0x000000, "Member 'GlowManager_OnPerceived::Actor' has a wrong offset!");
static_assert(offsetof(GlowManager_OnPerceived, Stimulus) == 0x000008, "Member 'GlowManager_OnPerceived::Stimulus' has a wrong offset!");

// Function Phoenix.PhxAISensor_Hearing.MakeAISoundEvent
// 0x0030 (0x0030 - 0x0000)
struct PhxAISensor_Hearing_MakeAISoundEvent final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 SourceActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Instigator;                                        // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAISoundLoudness                           SoundLoudness;                                     // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x3];                                       // 0x0019(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                OverrideSoundLocation;                             // 0x001C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxReceivers;                                      // 0x0028(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAISensor_Hearing_MakeAISoundEvent) == 0x000008, "Wrong alignment on PhxAISensor_Hearing_MakeAISoundEvent");
static_assert(sizeof(PhxAISensor_Hearing_MakeAISoundEvent) == 0x000030, "Wrong size on PhxAISensor_Hearing_MakeAISoundEvent");
static_assert(offsetof(PhxAISensor_Hearing_MakeAISoundEvent, WorldContextObject) == 0x000000, "Member 'PhxAISensor_Hearing_MakeAISoundEvent::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Hearing_MakeAISoundEvent, SourceActor) == 0x000008, "Member 'PhxAISensor_Hearing_MakeAISoundEvent::SourceActor' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Hearing_MakeAISoundEvent, Instigator) == 0x000010, "Member 'PhxAISensor_Hearing_MakeAISoundEvent::Instigator' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Hearing_MakeAISoundEvent, SoundLoudness) == 0x000018, "Member 'PhxAISensor_Hearing_MakeAISoundEvent::SoundLoudness' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Hearing_MakeAISoundEvent, OverrideSoundLocation) == 0x00001C, "Member 'PhxAISensor_Hearing_MakeAISoundEvent::OverrideSoundLocation' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Hearing_MakeAISoundEvent, MaxReceivers) == 0x000028, "Member 'PhxAISensor_Hearing_MakeAISoundEvent::MaxReceivers' has a wrong offset!");

// Function Phoenix.PhxMenu.HandleOnlineAccount
// 0x0008 (0x0008 - 0x0000)
struct PhxMenu_HandleOnlineAccount final
{
public:
	const class USDSOnlineAccount*                OnlineAccount;                                     // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMenu_HandleOnlineAccount) == 0x000008, "Wrong alignment on PhxMenu_HandleOnlineAccount");
static_assert(sizeof(PhxMenu_HandleOnlineAccount) == 0x000008, "Wrong size on PhxMenu_HandleOnlineAccount");
static_assert(offsetof(PhxMenu_HandleOnlineAccount, OnlineAccount) == 0x000000, "Member 'PhxMenu_HandleOnlineAccount::OnlineAccount' has a wrong offset!");

// Function Phoenix.PhxMenu.NotifyUserOnline
// 0x0010 (0x0010 - 0x0000)
struct PhxMenu_NotifyUserOnline final
{
public:
	bool                                          bIsConnected;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	const class USDSOnlineAccount*                OnlineAccount;                                     // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMenu_NotifyUserOnline) == 0x000008, "Wrong alignment on PhxMenu_NotifyUserOnline");
static_assert(sizeof(PhxMenu_NotifyUserOnline) == 0x000010, "Wrong size on PhxMenu_NotifyUserOnline");
static_assert(offsetof(PhxMenu_NotifyUserOnline, bIsConnected) == 0x000000, "Member 'PhxMenu_NotifyUserOnline::bIsConnected' has a wrong offset!");
static_assert(offsetof(PhxMenu_NotifyUserOnline, OnlineAccount) == 0x000008, "Member 'PhxMenu_NotifyUserOnline::OnlineAccount' has a wrong offset!");

// Function Phoenix.PhxMenu.GetSelectedElement
// 0x0008 (0x0008 - 0x0000)
struct PhxMenu_GetSelectedElement final
{
public:
	class UPhxSelectable*                         ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMenu_GetSelectedElement) == 0x000008, "Wrong alignment on PhxMenu_GetSelectedElement");
static_assert(sizeof(PhxMenu_GetSelectedElement) == 0x000008, "Wrong size on PhxMenu_GetSelectedElement");
static_assert(offsetof(PhxMenu_GetSelectedElement, ReturnValue) == 0x000000, "Member 'PhxMenu_GetSelectedElement::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayCondition.ExecuteCondition
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayCondition_ExecuteCondition final
{
public:
	struct FGameplayConditionContext              ContextData;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayCondition_ExecuteCondition) == 0x000008, "Wrong alignment on PhxGameplayCondition_ExecuteCondition");
static_assert(sizeof(PhxGameplayCondition_ExecuteCondition) == 0x000018, "Wrong size on PhxGameplayCondition_ExecuteCondition");
static_assert(offsetof(PhxGameplayCondition_ExecuteCondition, ContextData) == 0x000000, "Member 'PhxGameplayCondition_ExecuteCondition::ContextData' has a wrong offset!");
static_assert(offsetof(PhxGameplayCondition_ExecuteCondition, ReturnValue) == 0x000010, "Member 'PhxGameplayCondition_ExecuteCondition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayCondition.GetConditionSummaryStringBP
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayCondition_GetConditionSummaryStringBP final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayCondition_GetConditionSummaryStringBP) == 0x000008, "Wrong alignment on PhxGameplayCondition_GetConditionSummaryStringBP");
static_assert(sizeof(PhxGameplayCondition_GetConditionSummaryStringBP) == 0x000010, "Wrong size on PhxGameplayCondition_GetConditionSummaryStringBP");
static_assert(offsetof(PhxGameplayCondition_GetConditionSummaryStringBP, ReturnValue) == 0x000000, "Member 'PhxGameplayCondition_GetConditionSummaryStringBP::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayCondition.TestConditionBP
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayCondition_TestConditionBP final
{
public:
	struct FGameplayConditionContext              ContextData;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayCondition_TestConditionBP) == 0x000008, "Wrong alignment on PhxGameplayCondition_TestConditionBP");
static_assert(sizeof(PhxGameplayCondition_TestConditionBP) == 0x000018, "Wrong size on PhxGameplayCondition_TestConditionBP");
static_assert(offsetof(PhxGameplayCondition_TestConditionBP, ContextData) == 0x000000, "Member 'PhxGameplayCondition_TestConditionBP::ContextData' has a wrong offset!");
static_assert(offsetof(PhxGameplayCondition_TestConditionBP, ReturnValue) == 0x000010, "Member 'PhxGameplayCondition_TestConditionBP::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAutoAim.HandleGamePaused
// 0x0001 (0x0001 - 0x0000)
struct PhxAutoAim_HandleGamePaused final
{
public:
	bool                                          bPaused;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutoAim_HandleGamePaused) == 0x000001, "Wrong alignment on PhxAutoAim_HandleGamePaused");
static_assert(sizeof(PhxAutoAim_HandleGamePaused) == 0x000001, "Wrong size on PhxAutoAim_HandleGamePaused");
static_assert(offsetof(PhxAutoAim_HandleGamePaused, bPaused) == 0x000000, "Member 'PhxAutoAim_HandleGamePaused::bPaused' has a wrong offset!");

// Function Phoenix.PhxAutoAim.OnRangedWeaponFired
// 0x0010 (0x0010 - 0x0000)
struct PhxAutoAim_OnRangedWeaponFired final
{
public:
	class APhxPlayerCharacter*                    Player;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxGunWeapon*                          Weapon;                                            // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutoAim_OnRangedWeaponFired) == 0x000008, "Wrong alignment on PhxAutoAim_OnRangedWeaponFired");
static_assert(sizeof(PhxAutoAim_OnRangedWeaponFired) == 0x000010, "Wrong size on PhxAutoAim_OnRangedWeaponFired");
static_assert(offsetof(PhxAutoAim_OnRangedWeaponFired, Player) == 0x000000, "Member 'PhxAutoAim_OnRangedWeaponFired::Player' has a wrong offset!");
static_assert(offsetof(PhxAutoAim_OnRangedWeaponFired, Weapon) == 0x000008, "Member 'PhxAutoAim_OnRangedWeaponFired::Weapon' has a wrong offset!");

// Function Phoenix.PhxCameraModifier.CombinePostProcessMaterials
// 0x11B0 (0x11B0 - 0x0000)
struct PhxCameraModifier_CombinePostProcessMaterials final
{
public:
	struct FPostProcessSettings                   A;                                                 // 0x0000(0x05E0)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FPostProcessSettings                   B;                                                 // 0x05E0(0x05E0)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	float                                         WeightScale;                                       // 0x0BC0(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BC4[0xC];                                      // 0x0BC4(0x000C)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPostProcessSettings                   ReturnValue;                                       // 0x0BD0(0x05E0)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraModifier_CombinePostProcessMaterials) == 0x000010, "Wrong alignment on PhxCameraModifier_CombinePostProcessMaterials");
static_assert(sizeof(PhxCameraModifier_CombinePostProcessMaterials) == 0x0011B0, "Wrong size on PhxCameraModifier_CombinePostProcessMaterials");
static_assert(offsetof(PhxCameraModifier_CombinePostProcessMaterials, A) == 0x000000, "Member 'PhxCameraModifier_CombinePostProcessMaterials::A' has a wrong offset!");
static_assert(offsetof(PhxCameraModifier_CombinePostProcessMaterials, B) == 0x0005E0, "Member 'PhxCameraModifier_CombinePostProcessMaterials::B' has a wrong offset!");
static_assert(offsetof(PhxCameraModifier_CombinePostProcessMaterials, WeightScale) == 0x000BC0, "Member 'PhxCameraModifier_CombinePostProcessMaterials::WeightScale' has a wrong offset!");
static_assert(offsetof(PhxCameraModifier_CombinePostProcessMaterials, ReturnValue) == 0x000BD0, "Member 'PhxCameraModifier_CombinePostProcessMaterials::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraModifier.GetAge
// 0x0008 (0x0008 - 0x0000)
struct PhxCameraModifier_GetAge final
{
public:
	float                                         Seconds;                                           // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Frames;                                            // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraModifier_GetAge) == 0x000004, "Wrong alignment on PhxCameraModifier_GetAge");
static_assert(sizeof(PhxCameraModifier_GetAge) == 0x000008, "Wrong size on PhxCameraModifier_GetAge");
static_assert(offsetof(PhxCameraModifier_GetAge, Seconds) == 0x000000, "Member 'PhxCameraModifier_GetAge::Seconds' has a wrong offset!");
static_assert(offsetof(PhxCameraModifier_GetAge, Frames) == 0x000004, "Member 'PhxCameraModifier_GetAge::Frames' has a wrong offset!");

// Function Phoenix.PhxCameraModifier.GetAlpha
// 0x0004 (0x0004 - 0x0000)
struct PhxCameraModifier_GetAlpha final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraModifier_GetAlpha) == 0x000004, "Wrong alignment on PhxCameraModifier_GetAlpha");
static_assert(sizeof(PhxCameraModifier_GetAlpha) == 0x000004, "Wrong size on PhxCameraModifier_GetAlpha");
static_assert(offsetof(PhxCameraModifier_GetAlpha, ReturnValue) == 0x000000, "Member 'PhxCameraModifier_GetAlpha::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraModifier.GetOwningRig
// 0x0008 (0x0008 - 0x0000)
struct PhxCameraModifier_GetOwningRig final
{
public:
	class APhxCameraRig*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraModifier_GetOwningRig) == 0x000008, "Wrong alignment on PhxCameraModifier_GetOwningRig");
static_assert(sizeof(PhxCameraModifier_GetOwningRig) == 0x000008, "Wrong size on PhxCameraModifier_GetOwningRig");
static_assert(offsetof(PhxCameraModifier_GetOwningRig, ReturnValue) == 0x000000, "Member 'PhxCameraModifier_GetOwningRig::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraModifier.IsAlive
// 0x0001 (0x0001 - 0x0000)
struct PhxCameraModifier_IsAlive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraModifier_IsAlive) == 0x000001, "Wrong alignment on PhxCameraModifier_IsAlive");
static_assert(sizeof(PhxCameraModifier_IsAlive) == 0x000001, "Wrong size on PhxCameraModifier_IsAlive");
static_assert(offsetof(PhxCameraModifier_IsAlive, ReturnValue) == 0x000000, "Member 'PhxCameraModifier_IsAlive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraModifier.IsDead
// 0x0001 (0x0001 - 0x0000)
struct PhxCameraModifier_IsDead final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraModifier_IsDead) == 0x000001, "Wrong alignment on PhxCameraModifier_IsDead");
static_assert(sizeof(PhxCameraModifier_IsDead) == 0x000001, "Wrong size on PhxCameraModifier_IsDead");
static_assert(offsetof(PhxCameraModifier_IsDead, ReturnValue) == 0x000000, "Member 'PhxCameraModifier_IsDead::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraModifier.IsDying
// 0x0001 (0x0001 - 0x0000)
struct PhxCameraModifier_IsDying final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraModifier_IsDying) == 0x000001, "Wrong alignment on PhxCameraModifier_IsDying");
static_assert(sizeof(PhxCameraModifier_IsDying) == 0x000001, "Wrong size on PhxCameraModifier_IsDying");
static_assert(offsetof(PhxCameraModifier_IsDying, ReturnValue) == 0x000000, "Member 'PhxCameraModifier_IsDying::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterCameraModifier.GetCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterCameraModifier_GetCharacter final
{
public:
	class APhxCharacter*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterCameraModifier_GetCharacter) == 0x000008, "Wrong alignment on PhxCharacterCameraModifier_GetCharacter");
static_assert(sizeof(PhxCharacterCameraModifier_GetCharacter) == 0x000008, "Wrong size on PhxCharacterCameraModifier_GetCharacter");
static_assert(offsetof(PhxCharacterCameraModifier_GetCharacter, ReturnValue) == 0x000000, "Member 'PhxCharacterCameraModifier_GetCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterCameraModifier.GetRig
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterCameraModifier_GetRig final
{
public:
	class APhxCameraRig*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterCameraModifier_GetRig) == 0x000008, "Wrong alignment on PhxCharacterCameraModifier_GetRig");
static_assert(sizeof(PhxCharacterCameraModifier_GetRig) == 0x000008, "Wrong size on PhxCharacterCameraModifier_GetRig");
static_assert(offsetof(PhxCharacterCameraModifier_GetRig, ReturnValue) == 0x000000, "Member 'PhxCharacterCameraModifier_GetRig::ReturnValue' has a wrong offset!");

// Function Phoenix.HealthBlurCameraModifier.SetTargetWeight
// 0x0004 (0x0004 - 0x0000)
struct HealthBlurCameraModifier_SetTargetWeight final
{
public:
	float                                         NewTarget;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HealthBlurCameraModifier_SetTargetWeight) == 0x000004, "Wrong alignment on HealthBlurCameraModifier_SetTargetWeight");
static_assert(sizeof(HealthBlurCameraModifier_SetTargetWeight) == 0x000004, "Wrong size on HealthBlurCameraModifier_SetTargetWeight");
static_assert(offsetof(HealthBlurCameraModifier_SetTargetWeight, NewTarget) == 0x000000, "Member 'HealthBlurCameraModifier_SetTargetWeight::NewTarget' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_WaitForDamageEvent.OnActorRecievedDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage) == 0x000008, "Wrong alignment on PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage");
static_assert(sizeof(PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage) == 0x000028, "Wrong size on PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage");
static_assert(offsetof(PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage, DamagedActor) == 0x000000, "Member 'PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage, Damage) == 0x000008, "Member 'PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage, DamageType) == 0x000010, "Member 'PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage, InstigatedBy) == 0x000018, "Member 'PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage, DamageCauser) == 0x000020, "Member 'PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxInputDebugger.OnInputKey
// 0x0020 (0x0020 - 0x0000)
struct PhxInputDebugger_OnInputKey final
{
public:
	struct FKey                                   Key;                                               // 0x0000(0x0018)(ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputEvent                                   EventType;                                         // 0x0018(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x3];                                       // 0x0019(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AmountDepressed;                                   // 0x001C(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputDebugger_OnInputKey) == 0x000008, "Wrong alignment on PhxInputDebugger_OnInputKey");
static_assert(sizeof(PhxInputDebugger_OnInputKey) == 0x000020, "Wrong size on PhxInputDebugger_OnInputKey");
static_assert(offsetof(PhxInputDebugger_OnInputKey, Key) == 0x000000, "Member 'PhxInputDebugger_OnInputKey::Key' has a wrong offset!");
static_assert(offsetof(PhxInputDebugger_OnInputKey, EventType) == 0x000018, "Member 'PhxInputDebugger_OnInputKey::EventType' has a wrong offset!");
static_assert(offsetof(PhxInputDebugger_OnInputKey, AmountDepressed) == 0x00001C, "Member 'PhxInputDebugger_OnInputKey::AmountDepressed' has a wrong offset!");

// Function Phoenix.HighContrastComponent.ApplyHighContrast
// 0x0001 (0x0001 - 0x0000)
struct HighContrastComponent_ApplyHighContrast final
{
public:
	bool                                          bInHighContrastEnabled;                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HighContrastComponent_ApplyHighContrast) == 0x000001, "Wrong alignment on HighContrastComponent_ApplyHighContrast");
static_assert(sizeof(HighContrastComponent_ApplyHighContrast) == 0x000001, "Wrong size on HighContrastComponent_ApplyHighContrast");
static_assert(offsetof(HighContrastComponent_ApplyHighContrast, bInHighContrastEnabled) == 0x000000, "Member 'HighContrastComponent_ApplyHighContrast::bInHighContrastEnabled' has a wrong offset!");

// Function Phoenix.HighContrastComponent.ApplySnowDeform
// 0x0001 (0x0001 - 0x0000)
struct HighContrastComponent_ApplySnowDeform final
{
public:
	bool                                          bInSnowDeformEnabled;                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HighContrastComponent_ApplySnowDeform) == 0x000001, "Wrong alignment on HighContrastComponent_ApplySnowDeform");
static_assert(sizeof(HighContrastComponent_ApplySnowDeform) == 0x000001, "Wrong size on HighContrastComponent_ApplySnowDeform");
static_assert(offsetof(HighContrastComponent_ApplySnowDeform, bInSnowDeformEnabled) == 0x000000, "Member 'HighContrastComponent_ApplySnowDeform::bInSnowDeformEnabled' has a wrong offset!");

// Function Phoenix.HighContrastComponent.SetPostProcessMaterialColors
// 0x0040 (0x0040 - 0x0000)
struct HighContrastComponent_SetPostProcessMaterialColors final
{
public:
	struct FLinearColor                           AllyColor;                                         // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           EnemyColor;                                        // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           PickupColor;                                       // 0x0020(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           HazardColor;                                       // 0x0030(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HighContrastComponent_SetPostProcessMaterialColors) == 0x000004, "Wrong alignment on HighContrastComponent_SetPostProcessMaterialColors");
static_assert(sizeof(HighContrastComponent_SetPostProcessMaterialColors) == 0x000040, "Wrong size on HighContrastComponent_SetPostProcessMaterialColors");
static_assert(offsetof(HighContrastComponent_SetPostProcessMaterialColors, AllyColor) == 0x000000, "Member 'HighContrastComponent_SetPostProcessMaterialColors::AllyColor' has a wrong offset!");
static_assert(offsetof(HighContrastComponent_SetPostProcessMaterialColors, EnemyColor) == 0x000010, "Member 'HighContrastComponent_SetPostProcessMaterialColors::EnemyColor' has a wrong offset!");
static_assert(offsetof(HighContrastComponent_SetPostProcessMaterialColors, PickupColor) == 0x000020, "Member 'HighContrastComponent_SetPostProcessMaterialColors::PickupColor' has a wrong offset!");
static_assert(offsetof(HighContrastComponent_SetPostProcessMaterialColors, HazardColor) == 0x000030, "Member 'HighContrastComponent_SetPostProcessMaterialColors::HazardColor' has a wrong offset!");

// Function Phoenix.HighContrastComponent.SetStencilAndApply
// 0x0001 (0x0001 - 0x0000)
struct HighContrastComponent_SetStencilAndApply final
{
public:
	EHighContrastStencil                          InValue;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HighContrastComponent_SetStencilAndApply) == 0x000001, "Wrong alignment on HighContrastComponent_SetStencilAndApply");
static_assert(sizeof(HighContrastComponent_SetStencilAndApply) == 0x000001, "Wrong size on HighContrastComponent_SetStencilAndApply");
static_assert(offsetof(HighContrastComponent_SetStencilAndApply, InValue) == 0x000000, "Member 'HighContrastComponent_SetStencilAndApply::InValue' has a wrong offset!");

// Function Phoenix.HighContrastComponent.SetStencilValue
// 0x0001 (0x0001 - 0x0000)
struct HighContrastComponent_SetStencilValue final
{
public:
	EHighContrastStencil                          InValue;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HighContrastComponent_SetStencilValue) == 0x000001, "Wrong alignment on HighContrastComponent_SetStencilValue");
static_assert(sizeof(HighContrastComponent_SetStencilValue) == 0x000001, "Wrong size on HighContrastComponent_SetStencilValue");
static_assert(offsetof(HighContrastComponent_SetStencilValue, InValue) == 0x000000, "Member 'HighContrastComponent_SetStencilValue::InValue' has a wrong offset!");

// Function Phoenix.PhxCharacterAnimInstanceBase.OnTakePointDamage
// 0x0058 (0x0058 - 0x0000)
struct PhxCharacterAnimInstanceBase_OnTakePointDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class AController*                            InstigatedBy;                                      // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                HitLocation;                                       // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPrimitiveComponent*                    FHitComponent;                                     // 0x0028(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BoneName;                                          // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ShotFromDirection;                                 // 0x0038(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0048(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0050(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterAnimInstanceBase_OnTakePointDamage) == 0x000008, "Wrong alignment on PhxCharacterAnimInstanceBase_OnTakePointDamage");
static_assert(sizeof(PhxCharacterAnimInstanceBase_OnTakePointDamage) == 0x000058, "Wrong size on PhxCharacterAnimInstanceBase_OnTakePointDamage");
static_assert(offsetof(PhxCharacterAnimInstanceBase_OnTakePointDamage, DamagedActor) == 0x000000, "Member 'PhxCharacterAnimInstanceBase_OnTakePointDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxCharacterAnimInstanceBase_OnTakePointDamage, Damage) == 0x000008, "Member 'PhxCharacterAnimInstanceBase_OnTakePointDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxCharacterAnimInstanceBase_OnTakePointDamage, InstigatedBy) == 0x000010, "Member 'PhxCharacterAnimInstanceBase_OnTakePointDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxCharacterAnimInstanceBase_OnTakePointDamage, HitLocation) == 0x000018, "Member 'PhxCharacterAnimInstanceBase_OnTakePointDamage::HitLocation' has a wrong offset!");
static_assert(offsetof(PhxCharacterAnimInstanceBase_OnTakePointDamage, FHitComponent) == 0x000028, "Member 'PhxCharacterAnimInstanceBase_OnTakePointDamage::FHitComponent' has a wrong offset!");
static_assert(offsetof(PhxCharacterAnimInstanceBase_OnTakePointDamage, BoneName) == 0x000030, "Member 'PhxCharacterAnimInstanceBase_OnTakePointDamage::BoneName' has a wrong offset!");
static_assert(offsetof(PhxCharacterAnimInstanceBase_OnTakePointDamage, ShotFromDirection) == 0x000038, "Member 'PhxCharacterAnimInstanceBase_OnTakePointDamage::ShotFromDirection' has a wrong offset!");
static_assert(offsetof(PhxCharacterAnimInstanceBase_OnTakePointDamage, DamageType) == 0x000048, "Member 'PhxCharacterAnimInstanceBase_OnTakePointDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxCharacterAnimInstanceBase_OnTakePointDamage, DamageCauser) == 0x000050, "Member 'PhxCharacterAnimInstanceBase_OnTakePointDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.GRPChargeComponent.AddCharge
// 0x0004 (0x0004 - 0x0000)
struct GRPChargeComponent_AddCharge final
{
public:
	float                                         Amount;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPChargeComponent_AddCharge) == 0x000004, "Wrong alignment on GRPChargeComponent_AddCharge");
static_assert(sizeof(GRPChargeComponent_AddCharge) == 0x000004, "Wrong size on GRPChargeComponent_AddCharge");
static_assert(offsetof(GRPChargeComponent_AddCharge, Amount) == 0x000000, "Member 'GRPChargeComponent_AddCharge::Amount' has a wrong offset!");

// Function Phoenix.GRPChargeComponent.GetCharge
// 0x0004 (0x0004 - 0x0000)
struct GRPChargeComponent_GetCharge final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPChargeComponent_GetCharge) == 0x000004, "Wrong alignment on GRPChargeComponent_GetCharge");
static_assert(sizeof(GRPChargeComponent_GetCharge) == 0x000004, "Wrong size on GRPChargeComponent_GetCharge");
static_assert(offsetof(GRPChargeComponent_GetCharge, ReturnValue) == 0x000000, "Member 'GRPChargeComponent_GetCharge::ReturnValue' has a wrong offset!");

// Function Phoenix.GRPChargeComponent.GetMaxCharge
// 0x0004 (0x0004 - 0x0000)
struct GRPChargeComponent_GetMaxCharge final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPChargeComponent_GetMaxCharge) == 0x000004, "Wrong alignment on GRPChargeComponent_GetMaxCharge");
static_assert(sizeof(GRPChargeComponent_GetMaxCharge) == 0x000004, "Wrong size on GRPChargeComponent_GetMaxCharge");
static_assert(offsetof(GRPChargeComponent_GetMaxCharge, ReturnValue) == 0x000000, "Member 'GRPChargeComponent_GetMaxCharge::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAutoBotPlayerLeash.FindActiveLeash
// 0x0010 (0x0010 - 0x0000)
struct PhxAutoBotPlayerLeash_FindActiveLeash final
{
public:
	const class UObject*                          InWorldObject;                                     // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAutoBotPlayerLeash*                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutoBotPlayerLeash_FindActiveLeash) == 0x000008, "Wrong alignment on PhxAutoBotPlayerLeash_FindActiveLeash");
static_assert(sizeof(PhxAutoBotPlayerLeash_FindActiveLeash) == 0x000010, "Wrong size on PhxAutoBotPlayerLeash_FindActiveLeash");
static_assert(offsetof(PhxAutoBotPlayerLeash_FindActiveLeash, InWorldObject) == 0x000000, "Member 'PhxAutoBotPlayerLeash_FindActiveLeash::InWorldObject' has a wrong offset!");
static_assert(offsetof(PhxAutoBotPlayerLeash_FindActiveLeash, ReturnValue) == 0x000008, "Member 'PhxAutoBotPlayerLeash_FindActiveLeash::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAutoBotPlayerLeash.FindNextActiveLeash
// 0x0010 (0x0010 - 0x0000)
struct PhxAutoBotPlayerLeash_FindNextActiveLeash final
{
public:
	const class UObject*                          InWorldObject;                                     // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAutoBotPlayerLeash*                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutoBotPlayerLeash_FindNextActiveLeash) == 0x000008, "Wrong alignment on PhxAutoBotPlayerLeash_FindNextActiveLeash");
static_assert(sizeof(PhxAutoBotPlayerLeash_FindNextActiveLeash) == 0x000010, "Wrong size on PhxAutoBotPlayerLeash_FindNextActiveLeash");
static_assert(offsetof(PhxAutoBotPlayerLeash_FindNextActiveLeash, InWorldObject) == 0x000000, "Member 'PhxAutoBotPlayerLeash_FindNextActiveLeash::InWorldObject' has a wrong offset!");
static_assert(offsetof(PhxAutoBotPlayerLeash_FindNextActiveLeash, ReturnValue) == 0x000008, "Member 'PhxAutoBotPlayerLeash_FindNextActiveLeash::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAutoBotPlayerLeash.CanLeashActivate
// 0x0001 (0x0001 - 0x0000)
struct PhxAutoBotPlayerLeash_CanLeashActivate final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutoBotPlayerLeash_CanLeashActivate) == 0x000001, "Wrong alignment on PhxAutoBotPlayerLeash_CanLeashActivate");
static_assert(sizeof(PhxAutoBotPlayerLeash_CanLeashActivate) == 0x000001, "Wrong size on PhxAutoBotPlayerLeash_CanLeashActivate");
static_assert(offsetof(PhxAutoBotPlayerLeash_CanLeashActivate, ReturnValue) == 0x000000, "Member 'PhxAutoBotPlayerLeash_CanLeashActivate::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAutoBotPlayerLeash.GetDesiredLocation
// 0x000C (0x000C - 0x0000)
struct PhxAutoBotPlayerLeash_GetDesiredLocation final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutoBotPlayerLeash_GetDesiredLocation) == 0x000004, "Wrong alignment on PhxAutoBotPlayerLeash_GetDesiredLocation");
static_assert(sizeof(PhxAutoBotPlayerLeash_GetDesiredLocation) == 0x00000C, "Wrong size on PhxAutoBotPlayerLeash_GetDesiredLocation");
static_assert(offsetof(PhxAutoBotPlayerLeash_GetDesiredLocation, ReturnValue) == 0x000000, "Member 'PhxAutoBotPlayerLeash_GetDesiredLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAutoBotPlayerLeash.IsLeashActive
// 0x0001 (0x0001 - 0x0000)
struct PhxAutoBotPlayerLeash_IsLeashActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutoBotPlayerLeash_IsLeashActive) == 0x000001, "Wrong alignment on PhxAutoBotPlayerLeash_IsLeashActive");
static_assert(sizeof(PhxAutoBotPlayerLeash_IsLeashActive) == 0x000001, "Wrong size on PhxAutoBotPlayerLeash_IsLeashActive");
static_assert(offsetof(PhxAutoBotPlayerLeash_IsLeashActive, ReturnValue) == 0x000000, "Member 'PhxAutoBotPlayerLeash_IsLeashActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISensor_Touch.HandleActorHit
// 0x00A8 (0x00A8 - 0x0000)
struct PhxAISensor_Touch_HandleActorHit final
{
public:
	class AActor*                                 SelfActor;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0010(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x001C(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_A4[0x4];                                       // 0x00A4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAISensor_Touch_HandleActorHit) == 0x000008, "Wrong alignment on PhxAISensor_Touch_HandleActorHit");
static_assert(sizeof(PhxAISensor_Touch_HandleActorHit) == 0x0000A8, "Wrong size on PhxAISensor_Touch_HandleActorHit");
static_assert(offsetof(PhxAISensor_Touch_HandleActorHit, SelfActor) == 0x000000, "Member 'PhxAISensor_Touch_HandleActorHit::SelfActor' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Touch_HandleActorHit, OtherActor) == 0x000008, "Member 'PhxAISensor_Touch_HandleActorHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Touch_HandleActorHit, NormalImpulse) == 0x000010, "Member 'PhxAISensor_Touch_HandleActorHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Touch_HandleActorHit, Hit) == 0x00001C, "Member 'PhxAISensor_Touch_HandleActorHit::Hit' has a wrong offset!");

// Function Phoenix.PhxCameraMover.Tick
// 0x06E0 (0x06E0 - 0x0000)
struct PhxCameraMover_Tick final
{
public:
	struct FPhxCameraProperties                   DesiredProperties;                                 // 0x0000(0x06D0)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	float                                         DeltaTime;                                         // 0x06D0(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6D4[0xC];                                      // 0x06D4(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCameraMover_Tick) == 0x000010, "Wrong alignment on PhxCameraMover_Tick");
static_assert(sizeof(PhxCameraMover_Tick) == 0x0006E0, "Wrong size on PhxCameraMover_Tick");
static_assert(offsetof(PhxCameraMover_Tick, DesiredProperties) == 0x000000, "Member 'PhxCameraMover_Tick::DesiredProperties' has a wrong offset!");
static_assert(offsetof(PhxCameraMover_Tick, DeltaTime) == 0x0006D0, "Member 'PhxCameraMover_Tick::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxCameraMover.GetDesiredLocation
// 0x000C (0x000C - 0x0000)
struct PhxCameraMover_GetDesiredLocation final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraMover_GetDesiredLocation) == 0x000004, "Wrong alignment on PhxCameraMover_GetDesiredLocation");
static_assert(sizeof(PhxCameraMover_GetDesiredLocation) == 0x00000C, "Wrong size on PhxCameraMover_GetDesiredLocation");
static_assert(offsetof(PhxCameraMover_GetDesiredLocation, ReturnValue) == 0x000000, "Member 'PhxCameraMover_GetDesiredLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraMover.GetResolvedCameraTransform
// 0x0030 (0x0030 - 0x0000)
struct PhxCameraMover_GetResolvedCameraTransform final
{
public:
	struct FTransform                             ReturnValue;                                       // 0x0000(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraMover_GetResolvedCameraTransform) == 0x000010, "Wrong alignment on PhxCameraMover_GetResolvedCameraTransform");
static_assert(sizeof(PhxCameraMover_GetResolvedCameraTransform) == 0x000030, "Wrong size on PhxCameraMover_GetResolvedCameraTransform");
static_assert(offsetof(PhxCameraMover_GetResolvedCameraTransform, ReturnValue) == 0x000000, "Member 'PhxCameraMover_GetResolvedCameraTransform::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraMoverSpherecast.HasIgnoreTag
// 0x0010 (0x0010 - 0x0000)
struct PhxCameraMoverSpherecast_HasIgnoreTag final
{
public:
	const class UActorComponent*                  Component;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCameraMoverSpherecast_HasIgnoreTag) == 0x000008, "Wrong alignment on PhxCameraMoverSpherecast_HasIgnoreTag");
static_assert(sizeof(PhxCameraMoverSpherecast_HasIgnoreTag) == 0x000010, "Wrong size on PhxCameraMoverSpherecast_HasIgnoreTag");
static_assert(offsetof(PhxCameraMoverSpherecast_HasIgnoreTag, Component) == 0x000000, "Member 'PhxCameraMoverSpherecast_HasIgnoreTag::Component' has a wrong offset!");
static_assert(offsetof(PhxCameraMoverSpherecast_HasIgnoreTag, ReturnValue) == 0x000008, "Member 'PhxCameraMoverSpherecast_HasIgnoreTag::ReturnValue' has a wrong offset!");

// Function Phoenix.Consumable.CanStartConsuming
// 0x0010 (0x0010 - 0x0000)
struct Consumable_CanStartConsuming final
{
public:
	class APhxCharacter*                          ConsumedBy;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(Consumable_CanStartConsuming) == 0x000008, "Wrong alignment on Consumable_CanStartConsuming");
static_assert(sizeof(Consumable_CanStartConsuming) == 0x000010, "Wrong size on Consumable_CanStartConsuming");
static_assert(offsetof(Consumable_CanStartConsuming, ConsumedBy) == 0x000000, "Member 'Consumable_CanStartConsuming::ConsumedBy' has a wrong offset!");
static_assert(offsetof(Consumable_CanStartConsuming, ReturnValue) == 0x000008, "Member 'Consumable_CanStartConsuming::ReturnValue' has a wrong offset!");

// Function Phoenix.Consumable.OnConsumed
// 0x0008 (0x0008 - 0x0000)
struct Consumable_OnConsumed final
{
public:
	class APhxCharacter*                          ConsumedBy;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Consumable_OnConsumed) == 0x000008, "Wrong alignment on Consumable_OnConsumed");
static_assert(sizeof(Consumable_OnConsumed) == 0x000008, "Wrong size on Consumable_OnConsumed");
static_assert(offsetof(Consumable_OnConsumed, ConsumedBy) == 0x000000, "Member 'Consumable_OnConsumed::ConsumedBy' has a wrong offset!");

// Function Phoenix.Consumable.StopUsingConsumable
// 0x0008 (0x0008 - 0x0000)
struct Consumable_StopUsingConsumable final
{
public:
	class APhxCharacter*                          ConsumedBy;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Consumable_StopUsingConsumable) == 0x000008, "Wrong alignment on Consumable_StopUsingConsumable");
static_assert(sizeof(Consumable_StopUsingConsumable) == 0x000008, "Wrong size on Consumable_StopUsingConsumable");
static_assert(offsetof(Consumable_StopUsingConsumable, ConsumedBy) == 0x000000, "Member 'Consumable_StopUsingConsumable::ConsumedBy' has a wrong offset!");

// Function Phoenix.Consumable.UseConsumable
// 0x0008 (0x0008 - 0x0000)
struct Consumable_UseConsumable final
{
public:
	class APhxCharacter*                          ConsumedBy;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Consumable_UseConsumable) == 0x000008, "Wrong alignment on Consumable_UseConsumable");
static_assert(sizeof(Consumable_UseConsumable) == 0x000008, "Wrong size on Consumable_UseConsumable");
static_assert(offsetof(Consumable_UseConsumable, ConsumedBy) == 0x000000, "Member 'Consumable_UseConsumable::ConsumedBy' has a wrong offset!");

// Function Phoenix.HealthPack.GetHealAmount
// 0x0004 (0x0004 - 0x0000)
struct HealthPack_GetHealAmount final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HealthPack_GetHealAmount) == 0x000004, "Wrong alignment on HealthPack_GetHealAmount");
static_assert(sizeof(HealthPack_GetHealAmount) == 0x000004, "Wrong size on HealthPack_GetHealAmount");
static_assert(offsetof(HealthPack_GetHealAmount, ReturnValue) == 0x000000, "Member 'HealthPack_GetHealAmount::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.SetCameraAngleRequired
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_SetCameraAngleRequired final
{
public:
	float                                         Angle;                                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_SetCameraAngleRequired) == 0x000004, "Wrong alignment on InteractableComponent_SetCameraAngleRequired");
static_assert(sizeof(InteractableComponent_SetCameraAngleRequired) == 0x000004, "Wrong size on InteractableComponent_SetCameraAngleRequired");
static_assert(offsetof(InteractableComponent_SetCameraAngleRequired, Angle) == 0x000000, "Member 'InteractableComponent_SetCameraAngleRequired::Angle' has a wrong offset!");

// Function Phoenix.InteractableComponent.SetEnableInteraction
// 0x0001 (0x0001 - 0x0000)
struct InteractableComponent_SetEnableInteraction final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_SetEnableInteraction) == 0x000001, "Wrong alignment on InteractableComponent_SetEnableInteraction");
static_assert(sizeof(InteractableComponent_SetEnableInteraction) == 0x000001, "Wrong size on InteractableComponent_SetEnableInteraction");
static_assert(offsetof(InteractableComponent_SetEnableInteraction, bEnable) == 0x000000, "Member 'InteractableComponent_SetEnableInteraction::bEnable' has a wrong offset!");

// Function Phoenix.InteractableComponent.SetFocusableRadius
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_SetFocusableRadius final
{
public:
	float                                         Radius;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_SetFocusableRadius) == 0x000004, "Wrong alignment on InteractableComponent_SetFocusableRadius");
static_assert(sizeof(InteractableComponent_SetFocusableRadius) == 0x000004, "Wrong size on InteractableComponent_SetFocusableRadius");
static_assert(offsetof(InteractableComponent_SetFocusableRadius, Radius) == 0x000000, "Member 'InteractableComponent_SetFocusableRadius::Radius' has a wrong offset!");

// Function Phoenix.InteractableComponent.SetMoveToSyncPointBeforeInteract
// 0x0001 (0x0001 - 0x0000)
struct InteractableComponent_SetMoveToSyncPointBeforeInteract final
{
public:
	bool                                          bMoveToSyncPoint;                                  // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_SetMoveToSyncPointBeforeInteract) == 0x000001, "Wrong alignment on InteractableComponent_SetMoveToSyncPointBeforeInteract");
static_assert(sizeof(InteractableComponent_SetMoveToSyncPointBeforeInteract) == 0x000001, "Wrong size on InteractableComponent_SetMoveToSyncPointBeforeInteract");
static_assert(offsetof(InteractableComponent_SetMoveToSyncPointBeforeInteract, bMoveToSyncPoint) == 0x000000, "Member 'InteractableComponent_SetMoveToSyncPointBeforeInteract::bMoveToSyncPoint' has a wrong offset!");

// Function Phoenix.InteractableComponent.SetNearbyRadius
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_SetNearbyRadius final
{
public:
	float                                         Radius;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_SetNearbyRadius) == 0x000004, "Wrong alignment on InteractableComponent_SetNearbyRadius");
static_assert(sizeof(InteractableComponent_SetNearbyRadius) == 0x000004, "Wrong size on InteractableComponent_SetNearbyRadius");
static_assert(offsetof(InteractableComponent_SetNearbyRadius, Radius) == 0x000000, "Member 'InteractableComponent_SetNearbyRadius::Radius' has a wrong offset!");

// Function Phoenix.InteractableComponent.SetPlayerAngleRequired
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_SetPlayerAngleRequired final
{
public:
	float                                         Angle;                                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_SetPlayerAngleRequired) == 0x000004, "Wrong alignment on InteractableComponent_SetPlayerAngleRequired");
static_assert(sizeof(InteractableComponent_SetPlayerAngleRequired) == 0x000004, "Wrong size on InteractableComponent_SetPlayerAngleRequired");
static_assert(offsetof(InteractableComponent_SetPlayerAngleRequired, Angle) == 0x000000, "Member 'InteractableComponent_SetPlayerAngleRequired::Angle' has a wrong offset!");

// Function Phoenix.InteractableComponent.SetRelativeIconOffset
// 0x000C (0x000C - 0x0000)
struct InteractableComponent_SetRelativeIconOffset final
{
public:
	struct FVector                                NewOffset;                                         // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_SetRelativeIconOffset) == 0x000004, "Wrong alignment on InteractableComponent_SetRelativeIconOffset");
static_assert(sizeof(InteractableComponent_SetRelativeIconOffset) == 0x00000C, "Wrong size on InteractableComponent_SetRelativeIconOffset");
static_assert(offsetof(InteractableComponent_SetRelativeIconOffset, NewOffset) == 0x000000, "Member 'InteractableComponent_SetRelativeIconOffset::NewOffset' has a wrong offset!");

// Function Phoenix.InteractableComponent.SetSyncPointTransform
// 0x0030 (0x0030 - 0x0000)
struct InteractableComponent_SetSyncPointTransform final
{
public:
	struct FTransform                             WorldSpaceTransform;                               // 0x0000(0x0030)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_SetSyncPointTransform) == 0x000010, "Wrong alignment on InteractableComponent_SetSyncPointTransform");
static_assert(sizeof(InteractableComponent_SetSyncPointTransform) == 0x000030, "Wrong size on InteractableComponent_SetSyncPointTransform");
static_assert(offsetof(InteractableComponent_SetSyncPointTransform, WorldSpaceTransform) == 0x000000, "Member 'InteractableComponent_SetSyncPointTransform::WorldSpaceTransform' has a wrong offset!");

// Function Phoenix.InteractableComponent.SetZIconOffset
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_SetZIconOffset final
{
public:
	float                                         NewZOffset;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_SetZIconOffset) == 0x000004, "Wrong alignment on InteractableComponent_SetZIconOffset");
static_assert(sizeof(InteractableComponent_SetZIconOffset) == 0x000004, "Wrong size on InteractableComponent_SetZIconOffset");
static_assert(offsetof(InteractableComponent_SetZIconOffset, NewZOffset) == 0x000000, "Member 'InteractableComponent_SetZIconOffset::NewZOffset' has a wrong offset!");

// Function Phoenix.InteractableComponent.BlueprintCanAutoExecute
// 0x0010 (0x0010 - 0x0000)
struct InteractableComponent_BlueprintCanAutoExecute final
{
public:
	const class APhxCharacter*                    Character;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InteractableComponent_BlueprintCanAutoExecute) == 0x000008, "Wrong alignment on InteractableComponent_BlueprintCanAutoExecute");
static_assert(sizeof(InteractableComponent_BlueprintCanAutoExecute) == 0x000010, "Wrong size on InteractableComponent_BlueprintCanAutoExecute");
static_assert(offsetof(InteractableComponent_BlueprintCanAutoExecute, Character) == 0x000000, "Member 'InteractableComponent_BlueprintCanAutoExecute::Character' has a wrong offset!");
static_assert(offsetof(InteractableComponent_BlueprintCanAutoExecute, ReturnValue) == 0x000008, "Member 'InteractableComponent_BlueprintCanAutoExecute::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.ButtonCanExecute
// 0x0010 (0x0010 - 0x0000)
struct InteractableComponent_ButtonCanExecute final
{
public:
	const class APhxCharacter*                    Character;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InteractableComponent_ButtonCanExecute) == 0x000008, "Wrong alignment on InteractableComponent_ButtonCanExecute");
static_assert(sizeof(InteractableComponent_ButtonCanExecute) == 0x000010, "Wrong size on InteractableComponent_ButtonCanExecute");
static_assert(offsetof(InteractableComponent_ButtonCanExecute, Character) == 0x000000, "Member 'InteractableComponent_ButtonCanExecute::Character' has a wrong offset!");
static_assert(offsetof(InteractableComponent_ButtonCanExecute, ReturnValue) == 0x000008, "Member 'InteractableComponent_ButtonCanExecute::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.CanAutoExecute
// 0x0010 (0x0010 - 0x0000)
struct InteractableComponent_CanAutoExecute final
{
public:
	const class APhxCharacter*                    Character;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InteractableComponent_CanAutoExecute) == 0x000008, "Wrong alignment on InteractableComponent_CanAutoExecute");
static_assert(sizeof(InteractableComponent_CanAutoExecute) == 0x000010, "Wrong size on InteractableComponent_CanAutoExecute");
static_assert(offsetof(InteractableComponent_CanAutoExecute, Character) == 0x000000, "Member 'InteractableComponent_CanAutoExecute::Character' has a wrong offset!");
static_assert(offsetof(InteractableComponent_CanAutoExecute, ReturnValue) == 0x000008, "Member 'InteractableComponent_CanAutoExecute::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetCameraAngleRequired
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_GetCameraAngleRequired final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetCameraAngleRequired) == 0x000004, "Wrong alignment on InteractableComponent_GetCameraAngleRequired");
static_assert(sizeof(InteractableComponent_GetCameraAngleRequired) == 0x000004, "Wrong size on InteractableComponent_GetCameraAngleRequired");
static_assert(offsetof(InteractableComponent_GetCameraAngleRequired, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetCameraAngleRequired::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetCameraAngleRequiredCosine
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_GetCameraAngleRequiredCosine final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetCameraAngleRequiredCosine) == 0x000004, "Wrong alignment on InteractableComponent_GetCameraAngleRequiredCosine");
static_assert(sizeof(InteractableComponent_GetCameraAngleRequiredCosine) == 0x000004, "Wrong size on InteractableComponent_GetCameraAngleRequiredCosine");
static_assert(offsetof(InteractableComponent_GetCameraAngleRequiredCosine, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetCameraAngleRequiredCosine::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetFocusableQuadrance
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_GetFocusableQuadrance final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetFocusableQuadrance) == 0x000004, "Wrong alignment on InteractableComponent_GetFocusableQuadrance");
static_assert(sizeof(InteractableComponent_GetFocusableQuadrance) == 0x000004, "Wrong size on InteractableComponent_GetFocusableQuadrance");
static_assert(offsetof(InteractableComponent_GetFocusableQuadrance, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetFocusableQuadrance::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetFocusableRadius
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_GetFocusableRadius final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetFocusableRadius) == 0x000004, "Wrong alignment on InteractableComponent_GetFocusableRadius");
static_assert(sizeof(InteractableComponent_GetFocusableRadius) == 0x000004, "Wrong size on InteractableComponent_GetFocusableRadius");
static_assert(offsetof(InteractableComponent_GetFocusableRadius, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetFocusableRadius::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetInteractableButton
// 0x0001 (0x0001 - 0x0000)
struct InteractableComponent_GetInteractableButton final
{
public:
	EInteractionButton                            ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetInteractableButton) == 0x000001, "Wrong alignment on InteractableComponent_GetInteractableButton");
static_assert(sizeof(InteractableComponent_GetInteractableButton) == 0x000001, "Wrong size on InteractableComponent_GetInteractableButton");
static_assert(offsetof(InteractableComponent_GetInteractableButton, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetInteractableButton::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetInteractionMontage
// 0x0008 (0x0008 - 0x0000)
struct InteractableComponent_GetInteractionMontage final
{
public:
	class UAnimMontage*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetInteractionMontage) == 0x000008, "Wrong alignment on InteractableComponent_GetInteractionMontage");
static_assert(sizeof(InteractableComponent_GetInteractionMontage) == 0x000008, "Wrong size on InteractableComponent_GetInteractionMontage");
static_assert(offsetof(InteractableComponent_GetInteractionMontage, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetInteractionMontage::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetInteractionWidget
// 0x0008 (0x0008 - 0x0000)
struct InteractableComponent_GetInteractionWidget final
{
public:
	class AWSInteractionWidget*                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetInteractionWidget) == 0x000008, "Wrong alignment on InteractableComponent_GetInteractionWidget");
static_assert(sizeof(InteractableComponent_GetInteractionWidget) == 0x000008, "Wrong size on InteractableComponent_GetInteractionWidget");
static_assert(offsetof(InteractableComponent_GetInteractionWidget, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetInteractionWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetNearbyQuadrance
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_GetNearbyQuadrance final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetNearbyQuadrance) == 0x000004, "Wrong alignment on InteractableComponent_GetNearbyQuadrance");
static_assert(sizeof(InteractableComponent_GetNearbyQuadrance) == 0x000004, "Wrong size on InteractableComponent_GetNearbyQuadrance");
static_assert(offsetof(InteractableComponent_GetNearbyQuadrance, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetNearbyQuadrance::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetNearbyRadius
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_GetNearbyRadius final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetNearbyRadius) == 0x000004, "Wrong alignment on InteractableComponent_GetNearbyRadius");
static_assert(sizeof(InteractableComponent_GetNearbyRadius) == 0x000004, "Wrong size on InteractableComponent_GetNearbyRadius");
static_assert(offsetof(InteractableComponent_GetNearbyRadius, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetNearbyRadius::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetPlayerAngleRequired
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_GetPlayerAngleRequired final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetPlayerAngleRequired) == 0x000004, "Wrong alignment on InteractableComponent_GetPlayerAngleRequired");
static_assert(sizeof(InteractableComponent_GetPlayerAngleRequired) == 0x000004, "Wrong size on InteractableComponent_GetPlayerAngleRequired");
static_assert(offsetof(InteractableComponent_GetPlayerAngleRequired, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetPlayerAngleRequired::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetPlayerAngleRequiredCosine
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_GetPlayerAngleRequiredCosine final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetPlayerAngleRequiredCosine) == 0x000004, "Wrong alignment on InteractableComponent_GetPlayerAngleRequiredCosine");
static_assert(sizeof(InteractableComponent_GetPlayerAngleRequiredCosine) == 0x000004, "Wrong size on InteractableComponent_GetPlayerAngleRequiredCosine");
static_assert(offsetof(InteractableComponent_GetPlayerAngleRequiredCosine, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetPlayerAngleRequiredCosine::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetPlayerFacingAngleRequiredCosine
// 0x0004 (0x0004 - 0x0000)
struct InteractableComponent_GetPlayerFacingAngleRequiredCosine final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetPlayerFacingAngleRequiredCosine) == 0x000004, "Wrong alignment on InteractableComponent_GetPlayerFacingAngleRequiredCosine");
static_assert(sizeof(InteractableComponent_GetPlayerFacingAngleRequiredCosine) == 0x000004, "Wrong size on InteractableComponent_GetPlayerFacingAngleRequiredCosine");
static_assert(offsetof(InteractableComponent_GetPlayerFacingAngleRequiredCosine, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetPlayerFacingAngleRequiredCosine::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetProximityToPlayer
// 0x0001 (0x0001 - 0x0000)
struct InteractableComponent_GetProximityToPlayer final
{
public:
	EInteractableProximity                        ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetProximityToPlayer) == 0x000001, "Wrong alignment on InteractableComponent_GetProximityToPlayer");
static_assert(sizeof(InteractableComponent_GetProximityToPlayer) == 0x000001, "Wrong size on InteractableComponent_GetProximityToPlayer");
static_assert(offsetof(InteractableComponent_GetProximityToPlayer, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetProximityToPlayer::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.GetValidInteractions
// 0x0010 (0x0010 - 0x0000)
struct InteractableComponent_GetValidInteractions final
{
public:
	TArray<TSubclassOf<class UInteraction>>       ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, UObjectWrapper, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_GetValidInteractions) == 0x000008, "Wrong alignment on InteractableComponent_GetValidInteractions");
static_assert(sizeof(InteractableComponent_GetValidInteractions) == 0x000010, "Wrong size on InteractableComponent_GetValidInteractions");
static_assert(offsetof(InteractableComponent_GetValidInteractions, ReturnValue) == 0x000000, "Member 'InteractableComponent_GetValidInteractions::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.HasAnyValidInteraction
// 0x0010 (0x0010 - 0x0000)
struct InteractableComponent_HasAnyValidInteraction final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InteractableComponent_HasAnyValidInteraction) == 0x000008, "Wrong alignment on InteractableComponent_HasAnyValidInteraction");
static_assert(sizeof(InteractableComponent_HasAnyValidInteraction) == 0x000010, "Wrong size on InteractableComponent_HasAnyValidInteraction");
static_assert(offsetof(InteractableComponent_HasAnyValidInteraction, Character) == 0x000000, "Member 'InteractableComponent_HasAnyValidInteraction::Character' has a wrong offset!");
static_assert(offsetof(InteractableComponent_HasAnyValidInteraction, ReturnValue) == 0x000008, "Member 'InteractableComponent_HasAnyValidInteraction::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.InteractionBlocked
// 0x0001 (0x0001 - 0x0000)
struct InteractableComponent_InteractionBlocked final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_InteractionBlocked) == 0x000001, "Wrong alignment on InteractableComponent_InteractionBlocked");
static_assert(sizeof(InteractableComponent_InteractionBlocked) == 0x000001, "Wrong size on InteractableComponent_InteractionBlocked");
static_assert(offsetof(InteractableComponent_InteractionBlocked, ReturnValue) == 0x000000, "Member 'InteractableComponent_InteractionBlocked::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.InteractionEnabled
// 0x0001 (0x0001 - 0x0000)
struct InteractableComponent_InteractionEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableComponent_InteractionEnabled) == 0x000001, "Wrong alignment on InteractableComponent_InteractionEnabled");
static_assert(sizeof(InteractableComponent_InteractionEnabled) == 0x000001, "Wrong size on InteractableComponent_InteractionEnabled");
static_assert(offsetof(InteractableComponent_InteractionEnabled, ReturnValue) == 0x000000, "Member 'InteractableComponent_InteractionEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.IntersectValidInteractions
// 0x0028 (0x0028 - 0x0000)
struct InteractableComponent_IntersectValidInteractions final
{
public:
	TArray<TSubclassOf<class UInteraction>>       AvailableInteractions;                             // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<TSubclassOf<class UInteraction>>       Result;                                            // 0x0010(0x0010)(Parm, OutParm, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0020(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InteractableComponent_IntersectValidInteractions) == 0x000008, "Wrong alignment on InteractableComponent_IntersectValidInteractions");
static_assert(sizeof(InteractableComponent_IntersectValidInteractions) == 0x000028, "Wrong size on InteractableComponent_IntersectValidInteractions");
static_assert(offsetof(InteractableComponent_IntersectValidInteractions, AvailableInteractions) == 0x000000, "Member 'InteractableComponent_IntersectValidInteractions::AvailableInteractions' has a wrong offset!");
static_assert(offsetof(InteractableComponent_IntersectValidInteractions, Result) == 0x000010, "Member 'InteractableComponent_IntersectValidInteractions::Result' has a wrong offset!");
static_assert(offsetof(InteractableComponent_IntersectValidInteractions, ReturnValue) == 0x000020, "Member 'InteractableComponent_IntersectValidInteractions::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.IsInteractionClassValid
// 0x0010 (0x0010 - 0x0000)
struct InteractableComponent_IsInteractionClassValid final
{
public:
	TSubclassOf<class UInteraction>               InteractionClass;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InteractableComponent_IsInteractionClassValid) == 0x000008, "Wrong alignment on InteractableComponent_IsInteractionClassValid");
static_assert(sizeof(InteractableComponent_IsInteractionClassValid) == 0x000010, "Wrong size on InteractableComponent_IsInteractionClassValid");
static_assert(offsetof(InteractableComponent_IsInteractionClassValid, InteractionClass) == 0x000000, "Member 'InteractableComponent_IsInteractionClassValid::InteractionClass' has a wrong offset!");
static_assert(offsetof(InteractableComponent_IsInteractionClassValid, ReturnValue) == 0x000008, "Member 'InteractableComponent_IsInteractionClassValid::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractableComponent.IsInteractionValid
// 0x0010 (0x0010 - 0x0000)
struct InteractableComponent_IsInteractionValid final
{
public:
	class UInteraction*                           Interaction;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InteractableComponent_IsInteractionValid) == 0x000008, "Wrong alignment on InteractableComponent_IsInteractionValid");
static_assert(sizeof(InteractableComponent_IsInteractionValid) == 0x000010, "Wrong size on InteractableComponent_IsInteractionValid");
static_assert(offsetof(InteractableComponent_IsInteractionValid, Interaction) == 0x000000, "Member 'InteractableComponent_IsInteractionValid::Interaction' has a wrong offset!");
static_assert(offsetof(InteractableComponent_IsInteractionValid, ReturnValue) == 0x000008, "Member 'InteractableComponent_IsInteractionValid::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnGrappleStateEntered
// 0x0010 (0x0010 - 0x0000)
struct PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered final
{
public:
	class APhxCharacter*                          InCharacter;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAttackState*                           InAttackState;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered");
static_assert(sizeof(PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered) == 0x000010, "Wrong size on PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered");
static_assert(offsetof(PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered, InCharacter) == 0x000000, "Member 'PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered::InCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered, InAttackState) == 0x000008, "Member 'PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered::InAttackState' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnGrappleStateExited
// 0x0010 (0x0010 - 0x0000)
struct PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited final
{
public:
	class APhxCharacter*                          InCharacter;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAttackState*                           InAttackState;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited");
static_assert(sizeof(PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited) == 0x000010, "Wrong size on PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited");
static_assert(offsetof(PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited, InCharacter) == 0x000000, "Member 'PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited::InCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited, InAttackState) == 0x000008, "Member 'PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited::InAttackState' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnTargetEnteredGrapplePuppetState
// 0x0010 (0x0010 - 0x0000)
struct PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState final
{
public:
	class APhxCharacter*                          TargetCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UGrappledPuppetState*                   TargetGrappledPuppetState;                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState");
static_assert(sizeof(PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState) == 0x000010, "Wrong size on PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState");
static_assert(offsetof(PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState, TargetCharacter) == 0x000000, "Member 'PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState::TargetCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState, TargetGrappledPuppetState) == 0x000008, "Member 'PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState::TargetGrappledPuppetState' has a wrong offset!");

// Function Phoenix.PhxCraftingRecipe.GetIngredients
// 0x0050 (0x0050 - 0x0000)
struct PhxCraftingRecipe_GetIngredients final
{
public:
	TMap<TSubclassOf<class AItem>, int32>         ReturnValue;                                       // 0x0000(0x0050)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCraftingRecipe_GetIngredients) == 0x000008, "Wrong alignment on PhxCraftingRecipe_GetIngredients");
static_assert(sizeof(PhxCraftingRecipe_GetIngredients) == 0x000050, "Wrong size on PhxCraftingRecipe_GetIngredients");
static_assert(offsetof(PhxCraftingRecipe_GetIngredients, ReturnValue) == 0x000000, "Member 'PhxCraftingRecipe_GetIngredients::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCraftingRecipe.GetName
// 0x0018 (0x0018 - 0x0000)
struct PhxCraftingRecipe_GetName final
{
public:
	class FText                                   ReturnValue;                                       // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCraftingRecipe_GetName) == 0x000008, "Wrong alignment on PhxCraftingRecipe_GetName");
static_assert(sizeof(PhxCraftingRecipe_GetName) == 0x000018, "Wrong size on PhxCraftingRecipe_GetName");
static_assert(offsetof(PhxCraftingRecipe_GetName, ReturnValue) == 0x000000, "Member 'PhxCraftingRecipe_GetName::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCraftingRecipe.GetRecipeTags
// 0x0020 (0x0020 - 0x0000)
struct PhxCraftingRecipe_GetRecipeTags final
{
public:
	struct FGameplayTagContainer                  ReturnValue;                                       // 0x0000(0x0020)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCraftingRecipe_GetRecipeTags) == 0x000008, "Wrong alignment on PhxCraftingRecipe_GetRecipeTags");
static_assert(sizeof(PhxCraftingRecipe_GetRecipeTags) == 0x000020, "Wrong size on PhxCraftingRecipe_GetRecipeTags");
static_assert(offsetof(PhxCraftingRecipe_GetRecipeTags, ReturnValue) == 0x000000, "Member 'PhxCraftingRecipe_GetRecipeTags::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCraftingRecipe.GetUIModificationStats
// 0x0010 (0x0010 - 0x0000)
struct PhxCraftingRecipe_GetUIModificationStats final
{
public:
	TArray<struct FPhxUIModStat>                  ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCraftingRecipe_GetUIModificationStats) == 0x000008, "Wrong alignment on PhxCraftingRecipe_GetUIModificationStats");
static_assert(sizeof(PhxCraftingRecipe_GetUIModificationStats) == 0x000010, "Wrong size on PhxCraftingRecipe_GetUIModificationStats");
static_assert(offsetof(PhxCraftingRecipe_GetUIModificationStats, ReturnValue) == 0x000000, "Member 'PhxCraftingRecipe_GetUIModificationStats::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCraftingRecipe.GetUIModStatValue
// 0x0020 (0x0020 - 0x0000)
struct PhxCraftingRecipe_GetUIModStatValue final
{
public:
	class FText                                   InStatName;                                        // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0018(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCraftingRecipe_GetUIModStatValue) == 0x000008, "Wrong alignment on PhxCraftingRecipe_GetUIModStatValue");
static_assert(sizeof(PhxCraftingRecipe_GetUIModStatValue) == 0x000020, "Wrong size on PhxCraftingRecipe_GetUIModStatValue");
static_assert(offsetof(PhxCraftingRecipe_GetUIModStatValue, InStatName) == 0x000000, "Member 'PhxCraftingRecipe_GetUIModStatValue::InStatName' has a wrong offset!");
static_assert(offsetof(PhxCraftingRecipe_GetUIModStatValue, ReturnValue) == 0x000018, "Member 'PhxCraftingRecipe_GetUIModStatValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCraftingRecipe.GetVID
// 0x0008 (0x0008 - 0x0000)
struct PhxCraftingRecipe_GetVID final
{
public:
	class UVirtualItemData*                       ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCraftingRecipe_GetVID) == 0x000008, "Wrong alignment on PhxCraftingRecipe_GetVID");
static_assert(sizeof(PhxCraftingRecipe_GetVID) == 0x000008, "Wrong size on PhxCraftingRecipe_GetVID");
static_assert(offsetof(PhxCraftingRecipe_GetVID, ReturnValue) == 0x000000, "Member 'PhxCraftingRecipe_GetVID::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWeaponModificationRecipe.GetAttachmentSocket
// 0x0008 (0x0008 - 0x0000)
struct PhxWeaponModificationRecipe_GetAttachmentSocket final
{
public:
	class FName                                   ReturnValue;                                       // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponModificationRecipe_GetAttachmentSocket) == 0x000004, "Wrong alignment on PhxWeaponModificationRecipe_GetAttachmentSocket");
static_assert(sizeof(PhxWeaponModificationRecipe_GetAttachmentSocket) == 0x000008, "Wrong size on PhxWeaponModificationRecipe_GetAttachmentSocket");
static_assert(offsetof(PhxWeaponModificationRecipe_GetAttachmentSocket, ReturnValue) == 0x000000, "Member 'PhxWeaponModificationRecipe_GetAttachmentSocket::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWeaponModificationRecipe.GetWeaponModifications
// 0x0010 (0x0010 - 0x0000)
struct PhxWeaponModificationRecipe_GetWeaponModifications final
{
public:
	TArray<class UPhxWeaponModification*>         ReturnValue;                                       // 0x0000(0x0010)(ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponModificationRecipe_GetWeaponModifications) == 0x000008, "Wrong alignment on PhxWeaponModificationRecipe_GetWeaponModifications");
static_assert(sizeof(PhxWeaponModificationRecipe_GetWeaponModifications) == 0x000010, "Wrong size on PhxWeaponModificationRecipe_GetWeaponModifications");
static_assert(offsetof(PhxWeaponModificationRecipe_GetWeaponModifications, ReturnValue) == 0x000000, "Member 'PhxWeaponModificationRecipe_GetWeaponModifications::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDefaultMotionController.OnCharacterNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxDefaultMotionController_OnCharacterNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDefaultMotionController_OnCharacterNotifyReceived) == 0x000008, "Wrong alignment on PhxDefaultMotionController_OnCharacterNotifyReceived");
static_assert(sizeof(PhxDefaultMotionController_OnCharacterNotifyReceived) == 0x000008, "Wrong size on PhxDefaultMotionController_OnCharacterNotifyReceived");
static_assert(offsetof(PhxDefaultMotionController_OnCharacterNotifyReceived, Notify) == 0x000000, "Member 'PhxDefaultMotionController_OnCharacterNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.KeypadKey.GetValue
// 0x0004 (0x0004 - 0x0000)
struct KeypadKey_GetValue final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(KeypadKey_GetValue) == 0x000004, "Wrong alignment on KeypadKey_GetValue");
static_assert(sizeof(KeypadKey_GetValue) == 0x000004, "Wrong size on KeypadKey_GetValue");
static_assert(offsetof(KeypadKey_GetValue, ReturnValue) == 0x000000, "Member 'KeypadKey_GetValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxFlashlightModifier.IsDisabled
// 0x0001 (0x0001 - 0x0000)
struct PhxFlashlightModifier_IsDisabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFlashlightModifier_IsDisabled) == 0x000001, "Wrong alignment on PhxFlashlightModifier_IsDisabled");
static_assert(sizeof(PhxFlashlightModifier_IsDisabled) == 0x000001, "Wrong size on PhxFlashlightModifier_IsDisabled");
static_assert(offsetof(PhxFlashlightModifier_IsDisabled, ReturnValue) == 0x000000, "Member 'PhxFlashlightModifier_IsDisabled::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryPanel.GetSlotRowAndColumn
// 0x0010 (0x0010 - 0x0000)
struct InventoryPanel_GetSlotRowAndColumn final
{
public:
	const class UInventorySlot*                   InSlot;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OutRow;                                            // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OutCol;                                            // 0x000C(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryPanel_GetSlotRowAndColumn) == 0x000008, "Wrong alignment on InventoryPanel_GetSlotRowAndColumn");
static_assert(sizeof(InventoryPanel_GetSlotRowAndColumn) == 0x000010, "Wrong size on InventoryPanel_GetSlotRowAndColumn");
static_assert(offsetof(InventoryPanel_GetSlotRowAndColumn, InSlot) == 0x000000, "Member 'InventoryPanel_GetSlotRowAndColumn::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryPanel_GetSlotRowAndColumn, OutRow) == 0x000008, "Member 'InventoryPanel_GetSlotRowAndColumn::OutRow' has a wrong offset!");
static_assert(offsetof(InventoryPanel_GetSlotRowAndColumn, OutCol) == 0x00000C, "Member 'InventoryPanel_GetSlotRowAndColumn::OutCol' has a wrong offset!");

// Function Phoenix.InventoryPanel.GetAdjacentSlot
// 0x0018 (0x0018 - 0x0000)
struct InventoryPanel_GetAdjacentSlot final
{
public:
	const class UInventorySlot*                   InSlot;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UInventorySlot*                         ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryPanel_GetAdjacentSlot) == 0x000008, "Wrong alignment on InventoryPanel_GetAdjacentSlot");
static_assert(sizeof(InventoryPanel_GetAdjacentSlot) == 0x000018, "Wrong size on InventoryPanel_GetAdjacentSlot");
static_assert(offsetof(InventoryPanel_GetAdjacentSlot, InSlot) == 0x000000, "Member 'InventoryPanel_GetAdjacentSlot::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryPanel_GetAdjacentSlot, Direction) == 0x000008, "Member 'InventoryPanel_GetAdjacentSlot::Direction' has a wrong offset!");
static_assert(offsetof(InventoryPanel_GetAdjacentSlot, ReturnValue) == 0x000010, "Member 'InventoryPanel_GetAdjacentSlot::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryPanel.GetSelectedSlot
// 0x0008 (0x0008 - 0x0000)
struct InventoryPanel_GetSelectedSlot final
{
public:
	class UInventorySlot*                         ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryPanel_GetSelectedSlot) == 0x000008, "Wrong alignment on InventoryPanel_GetSelectedSlot");
static_assert(sizeof(InventoryPanel_GetSelectedSlot) == 0x000008, "Wrong size on InventoryPanel_GetSelectedSlot");
static_assert(offsetof(InventoryPanel_GetSelectedSlot, ReturnValue) == 0x000000, "Member 'InventoryPanel_GetSelectedSlot::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryBiosPanel.HandleAudioLogPlayed
// 0x0008 (0x0008 - 0x0000)
struct InventoryBiosPanel_HandleAudioLogPlayed final
{
public:
	class UDialogue*                              Dialogue;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryBiosPanel_HandleAudioLogPlayed) == 0x000008, "Wrong alignment on InventoryBiosPanel_HandleAudioLogPlayed");
static_assert(sizeof(InventoryBiosPanel_HandleAudioLogPlayed) == 0x000008, "Wrong size on InventoryBiosPanel_HandleAudioLogPlayed");
static_assert(offsetof(InventoryBiosPanel_HandleAudioLogPlayed, Dialogue) == 0x000000, "Member 'InventoryBiosPanel_HandleAudioLogPlayed::Dialogue' has a wrong offset!");

// Function Phoenix.InventoryBiosPanel.HandleBioDetailsFocus
// 0x0001 (0x0001 - 0x0000)
struct InventoryBiosPanel_HandleBioDetailsFocus final
{
public:
	bool                                          bIsFocused;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryBiosPanel_HandleBioDetailsFocus) == 0x000001, "Wrong alignment on InventoryBiosPanel_HandleBioDetailsFocus");
static_assert(sizeof(InventoryBiosPanel_HandleBioDetailsFocus) == 0x000001, "Wrong size on InventoryBiosPanel_HandleBioDetailsFocus");
static_assert(offsetof(InventoryBiosPanel_HandleBioDetailsFocus, bIsFocused) == 0x000000, "Member 'InventoryBiosPanel_HandleBioDetailsFocus::bIsFocused' has a wrong offset!");

// Function Phoenix.InventoryBiosPanel.HandleBioDetailsNavigation
// 0x0010 (0x0010 - 0x0000)
struct InventoryBiosPanel_HandleBioDetailsNavigation final
{
public:
	class UPhxSelectable*                         Selectable;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryBiosPanel_HandleBioDetailsNavigation) == 0x000008, "Wrong alignment on InventoryBiosPanel_HandleBioDetailsNavigation");
static_assert(sizeof(InventoryBiosPanel_HandleBioDetailsNavigation) == 0x000010, "Wrong size on InventoryBiosPanel_HandleBioDetailsNavigation");
static_assert(offsetof(InventoryBiosPanel_HandleBioDetailsNavigation, Selectable) == 0x000000, "Member 'InventoryBiosPanel_HandleBioDetailsNavigation::Selectable' has a wrong offset!");
static_assert(offsetof(InventoryBiosPanel_HandleBioDetailsNavigation, Direction) == 0x000008, "Member 'InventoryBiosPanel_HandleBioDetailsNavigation::Direction' has a wrong offset!");

// Function Phoenix.InventoryBiosPanel.HandleBioSelection
// 0x0010 (0x0010 - 0x0000)
struct InventoryBiosPanel_HandleBioSelection final
{
public:
	class UPhxSelectable*                         InSlot;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryBiosPanel_HandleBioSelection) == 0x000008, "Wrong alignment on InventoryBiosPanel_HandleBioSelection");
static_assert(sizeof(InventoryBiosPanel_HandleBioSelection) == 0x000010, "Wrong size on InventoryBiosPanel_HandleBioSelection");
static_assert(offsetof(InventoryBiosPanel_HandleBioSelection, InSlot) == 0x000000, "Member 'InventoryBiosPanel_HandleBioSelection::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryBiosPanel_HandleBioSelection, Direction) == 0x000008, "Member 'InventoryBiosPanel_HandleBioSelection::Direction' has a wrong offset!");

// Function Phoenix.InventoryBiosPanel.HandleIntelDetailsFocus
// 0x0001 (0x0001 - 0x0000)
struct InventoryBiosPanel_HandleIntelDetailsFocus final
{
public:
	bool                                          bIsFocused;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryBiosPanel_HandleIntelDetailsFocus) == 0x000001, "Wrong alignment on InventoryBiosPanel_HandleIntelDetailsFocus");
static_assert(sizeof(InventoryBiosPanel_HandleIntelDetailsFocus) == 0x000001, "Wrong size on InventoryBiosPanel_HandleIntelDetailsFocus");
static_assert(offsetof(InventoryBiosPanel_HandleIntelDetailsFocus, bIsFocused) == 0x000000, "Member 'InventoryBiosPanel_HandleIntelDetailsFocus::bIsFocused' has a wrong offset!");

// Function Phoenix.InventoryBiosPanel.HandleKeyCodeHintViewed
// 0x0001 (0x0001 - 0x0000)
struct InventoryBiosPanel_HandleKeyCodeHintViewed final
{
public:
	bool                                          bIsViewing;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryBiosPanel_HandleKeyCodeHintViewed) == 0x000001, "Wrong alignment on InventoryBiosPanel_HandleKeyCodeHintViewed");
static_assert(sizeof(InventoryBiosPanel_HandleKeyCodeHintViewed) == 0x000001, "Wrong size on InventoryBiosPanel_HandleKeyCodeHintViewed");
static_assert(offsetof(InventoryBiosPanel_HandleKeyCodeHintViewed, bIsViewing) == 0x000000, "Member 'InventoryBiosPanel_HandleKeyCodeHintViewed::bIsViewing' has a wrong offset!");

// Function Phoenix.InventoryBiosPanel.HandleLevelSelection
// 0x0008 (0x0008 - 0x0000)
struct InventoryBiosPanel_HandleLevelSelection final
{
public:
	int32                                         Index_0;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryBiosPanel_HandleLevelSelection) == 0x000004, "Wrong alignment on InventoryBiosPanel_HandleLevelSelection");
static_assert(sizeof(InventoryBiosPanel_HandleLevelSelection) == 0x000008, "Wrong size on InventoryBiosPanel_HandleLevelSelection");
static_assert(offsetof(InventoryBiosPanel_HandleLevelSelection, Index_0) == 0x000000, "Member 'InventoryBiosPanel_HandleLevelSelection::Index_0' has a wrong offset!");
static_assert(offsetof(InventoryBiosPanel_HandleLevelSelection, Direction) == 0x000004, "Member 'InventoryBiosPanel_HandleLevelSelection::Direction' has a wrong offset!");

// Function Phoenix.InventoryBiosPanel.HandleNavigationContainerChange
// 0x0010 (0x0010 - 0x0000)
struct InventoryBiosPanel_HandleNavigationContainerChange final
{
public:
	class UPanelWidget*                           Container;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryBiosPanel_HandleNavigationContainerChange) == 0x000008, "Wrong alignment on InventoryBiosPanel_HandleNavigationContainerChange");
static_assert(sizeof(InventoryBiosPanel_HandleNavigationContainerChange) == 0x000010, "Wrong size on InventoryBiosPanel_HandleNavigationContainerChange");
static_assert(offsetof(InventoryBiosPanel_HandleNavigationContainerChange, Container) == 0x000000, "Member 'InventoryBiosPanel_HandleNavigationContainerChange::Container' has a wrong offset!");
static_assert(offsetof(InventoryBiosPanel_HandleNavigationContainerChange, Direction) == 0x000008, "Member 'InventoryBiosPanel_HandleNavigationContainerChange::Direction' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent.HandleAIDestroyed
// 0x0008 (0x0008 - 0x0000)
struct PhxAISpawnerComponent_HandleAIDestroyed final
{
public:
	class AActor*                                 DestroyedActor;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_HandleAIDestroyed) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_HandleAIDestroyed");
static_assert(sizeof(PhxAISpawnerComponent_HandleAIDestroyed) == 0x000008, "Wrong size on PhxAISpawnerComponent_HandleAIDestroyed");
static_assert(offsetof(PhxAISpawnerComponent_HandleAIDestroyed, DestroyedActor) == 0x000000, "Member 'PhxAISpawnerComponent_HandleAIDestroyed::DestroyedActor' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent.HandleAIDied
// 0x0020 (0x0020 - 0x0000)
struct PhxAISpawnerComponent_HandleAIDied final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAISpawnerComponent_HandleAIDied) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_HandleAIDied");
static_assert(sizeof(PhxAISpawnerComponent_HandleAIDied) == 0x000020, "Wrong size on PhxAISpawnerComponent_HandleAIDied");
static_assert(offsetof(PhxAISpawnerComponent_HandleAIDied, DeadCharacter) == 0x000000, "Member 'PhxAISpawnerComponent_HandleAIDied::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAISpawnerComponent_HandleAIDied, KillerActor) == 0x000008, "Member 'PhxAISpawnerComponent_HandleAIDied::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAISpawnerComponent_HandleAIDied, KillerController) == 0x000010, "Member 'PhxAISpawnerComponent_HandleAIDied::KillerController' has a wrong offset!");
static_assert(offsetof(PhxAISpawnerComponent_HandleAIDied, KillingBlowHealthDelta) == 0x000018, "Member 'PhxAISpawnerComponent_HandleAIDied::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent.GetLastSpawnedAI
// 0x0008 (0x0008 - 0x0000)
struct PhxAISpawnerComponent_GetLastSpawnedAI final
{
public:
	class APhxAICharacter*                        ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_GetLastSpawnedAI) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_GetLastSpawnedAI");
static_assert(sizeof(PhxAISpawnerComponent_GetLastSpawnedAI) == 0x000008, "Wrong size on PhxAISpawnerComponent_GetLastSpawnedAI");
static_assert(offsetof(PhxAISpawnerComponent_GetLastSpawnedAI, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_GetLastSpawnedAI::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryEquipmentGridWidget.GetWidgetSwitcher
// 0x0008 (0x0008 - 0x0000)
struct InventoryEquipmentGridWidget_GetWidgetSwitcher final
{
public:
	class UWidgetSwitcher*                        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryEquipmentGridWidget_GetWidgetSwitcher) == 0x000008, "Wrong alignment on InventoryEquipmentGridWidget_GetWidgetSwitcher");
static_assert(sizeof(InventoryEquipmentGridWidget_GetWidgetSwitcher) == 0x000008, "Wrong size on InventoryEquipmentGridWidget_GetWidgetSwitcher");
static_assert(offsetof(InventoryEquipmentGridWidget_GetWidgetSwitcher, ReturnValue) == 0x000000, "Member 'InventoryEquipmentGridWidget_GetWidgetSwitcher::ReturnValue' has a wrong offset!");

// Function Phoenix.CharacterContextualAnimComponent.AddLightWeightContextualAnimTarget
// 0x0018 (0x0018 - 0x0000)
struct CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget final
{
public:
	class AActor*                                 TargetActor;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EHeadTrackingPriorityCategory                 PriorityCategory;                                  // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         PriorityValue;                                     // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          CheckLOS;                                          // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget) == 0x000008, "Wrong alignment on CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget");
static_assert(sizeof(CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget) == 0x000018, "Wrong size on CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget");
static_assert(offsetof(CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget, TargetActor) == 0x000000, "Member 'CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget::TargetActor' has a wrong offset!");
static_assert(offsetof(CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget, PriorityCategory) == 0x000008, "Member 'CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget::PriorityCategory' has a wrong offset!");
static_assert(offsetof(CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget, PriorityValue) == 0x00000C, "Member 'CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget::PriorityValue' has a wrong offset!");
static_assert(offsetof(CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget, CheckLOS) == 0x000010, "Member 'CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget::CheckLOS' has a wrong offset!");

// Function Phoenix.CharacterContextualAnimComponent.OnCharacterDeathEvent
// 0x0020 (0x0020 - 0x0000)
struct CharacterContextualAnimComponent_OnCharacterDeathEvent final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(CharacterContextualAnimComponent_OnCharacterDeathEvent) == 0x000008, "Wrong alignment on CharacterContextualAnimComponent_OnCharacterDeathEvent");
static_assert(sizeof(CharacterContextualAnimComponent_OnCharacterDeathEvent) == 0x000020, "Wrong size on CharacterContextualAnimComponent_OnCharacterDeathEvent");
static_assert(offsetof(CharacterContextualAnimComponent_OnCharacterDeathEvent, DeadCharacter) == 0x000000, "Member 'CharacterContextualAnimComponent_OnCharacterDeathEvent::DeadCharacter' has a wrong offset!");
static_assert(offsetof(CharacterContextualAnimComponent_OnCharacterDeathEvent, KillerActor) == 0x000008, "Member 'CharacterContextualAnimComponent_OnCharacterDeathEvent::KillerActor' has a wrong offset!");
static_assert(offsetof(CharacterContextualAnimComponent_OnCharacterDeathEvent, KillerController) == 0x000010, "Member 'CharacterContextualAnimComponent_OnCharacterDeathEvent::KillerController' has a wrong offset!");
static_assert(offsetof(CharacterContextualAnimComponent_OnCharacterDeathEvent, KillingBlowHealthDelta) == 0x000018, "Member 'CharacterContextualAnimComponent_OnCharacterDeathEvent::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.CharacterContextualAnimComponent.RemoveLightWeightContextualAnimTarget
// 0x0008 (0x0008 - 0x0000)
struct CharacterContextualAnimComponent_RemoveLightWeightContextualAnimTarget final
{
public:
	class AActor*                                 TargetActor;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CharacterContextualAnimComponent_RemoveLightWeightContextualAnimTarget) == 0x000008, "Wrong alignment on CharacterContextualAnimComponent_RemoveLightWeightContextualAnimTarget");
static_assert(sizeof(CharacterContextualAnimComponent_RemoveLightWeightContextualAnimTarget) == 0x000008, "Wrong size on CharacterContextualAnimComponent_RemoveLightWeightContextualAnimTarget");
static_assert(offsetof(CharacterContextualAnimComponent_RemoveLightWeightContextualAnimTarget, TargetActor) == 0x000000, "Member 'CharacterContextualAnimComponent_RemoveLightWeightContextualAnimTarget::TargetActor' has a wrong offset!");

// Function Phoenix.CharacterContextualAnimComponent.StartFullBodyContextualAnimation
// 0x0010 (0x0010 - 0x0000)
struct CharacterContextualAnimComponent_StartFullBodyContextualAnimation final
{
public:
	class UAnimMontage*                           Montage;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSwitchState;                                      // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUnarmedOnly;                                      // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(CharacterContextualAnimComponent_StartFullBodyContextualAnimation) == 0x000008, "Wrong alignment on CharacterContextualAnimComponent_StartFullBodyContextualAnimation");
static_assert(sizeof(CharacterContextualAnimComponent_StartFullBodyContextualAnimation) == 0x000010, "Wrong size on CharacterContextualAnimComponent_StartFullBodyContextualAnimation");
static_assert(offsetof(CharacterContextualAnimComponent_StartFullBodyContextualAnimation, Montage) == 0x000000, "Member 'CharacterContextualAnimComponent_StartFullBodyContextualAnimation::Montage' has a wrong offset!");
static_assert(offsetof(CharacterContextualAnimComponent_StartFullBodyContextualAnimation, bSwitchState) == 0x000008, "Member 'CharacterContextualAnimComponent_StartFullBodyContextualAnimation::bSwitchState' has a wrong offset!");
static_assert(offsetof(CharacterContextualAnimComponent_StartFullBodyContextualAnimation, bUnarmedOnly) == 0x000009, "Member 'CharacterContextualAnimComponent_StartFullBodyContextualAnimation::bUnarmedOnly' has a wrong offset!");

// Function Phoenix.CharacterContextualAnimComponent.UpdateCombatHeadTrackingTarget
// 0x0010 (0x0010 - 0x0000)
struct CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget final
{
public:
	class APhxCharacter*                          Attacker;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAttackState*                           AttackState;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget) == 0x000008, "Wrong alignment on CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget");
static_assert(sizeof(CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget) == 0x000010, "Wrong size on CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget");
static_assert(offsetof(CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget, Attacker) == 0x000000, "Member 'CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget::Attacker' has a wrong offset!");
static_assert(offsetof(CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget, AttackState) == 0x000008, "Member 'CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget::AttackState' has a wrong offset!");

// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveAIResourceAcquired
// 0x0008 (0x0008 - 0x0000)
struct PhxAIResource_BlueprintBase_ReceiveAIResourceAcquired final
{
public:
	class UObject*                                Owner;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIResource_BlueprintBase_ReceiveAIResourceAcquired) == 0x000008, "Wrong alignment on PhxAIResource_BlueprintBase_ReceiveAIResourceAcquired");
static_assert(sizeof(PhxAIResource_BlueprintBase_ReceiveAIResourceAcquired) == 0x000008, "Wrong size on PhxAIResource_BlueprintBase_ReceiveAIResourceAcquired");
static_assert(offsetof(PhxAIResource_BlueprintBase_ReceiveAIResourceAcquired, Owner) == 0x000000, "Member 'PhxAIResource_BlueprintBase_ReceiveAIResourceAcquired::Owner' has a wrong offset!");

// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveAIResourceReleased
// 0x0008 (0x0008 - 0x0000)
struct PhxAIResource_BlueprintBase_ReceiveAIResourceReleased final
{
public:
	class UObject*                                Owner;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIResource_BlueprintBase_ReceiveAIResourceReleased) == 0x000008, "Wrong alignment on PhxAIResource_BlueprintBase_ReceiveAIResourceReleased");
static_assert(sizeof(PhxAIResource_BlueprintBase_ReceiveAIResourceReleased) == 0x000008, "Wrong size on PhxAIResource_BlueprintBase_ReceiveAIResourceReleased");
static_assert(offsetof(PhxAIResource_BlueprintBase_ReceiveAIResourceReleased, Owner) == 0x000000, "Member 'PhxAIResource_BlueprintBase_ReceiveAIResourceReleased::Owner' has a wrong offset!");

// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveTick
// 0x0004 (0x0004 - 0x0000)
struct PhxAIResource_BlueprintBase_ReceiveTick final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIResource_BlueprintBase_ReceiveTick) == 0x000004, "Wrong alignment on PhxAIResource_BlueprintBase_ReceiveTick");
static_assert(sizeof(PhxAIResource_BlueprintBase_ReceiveTick) == 0x000004, "Wrong size on PhxAIResource_BlueprintBase_ReceiveTick");
static_assert(offsetof(PhxAIResource_BlueprintBase_ReceiveTick, DeltaTime) == 0x000000, "Member 'PhxAIResource_BlueprintBase_ReceiveTick::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveTryAcquireAIResource
// 0x0010 (0x0010 - 0x0000)
struct PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource final
{
public:
	class UObject*                                Requester;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource) == 0x000008, "Wrong alignment on PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource");
static_assert(sizeof(PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource) == 0x000010, "Wrong size on PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource");
static_assert(offsetof(PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource, Requester) == 0x000000, "Member 'PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource::Requester' has a wrong offset!");
static_assert(offsetof(PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource, ReturnValue) == 0x000008, "Member 'PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSpline.GetDirectionAlongSpline
// 0x001C (0x001C - 0x0000)
struct PhxSpline_GetDirectionAlongSpline final
{
public:
	float                                         Distance;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                Axis;                                              // 0x0004(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x0010(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSpline_GetDirectionAlongSpline) == 0x000004, "Wrong alignment on PhxSpline_GetDirectionAlongSpline");
static_assert(sizeof(PhxSpline_GetDirectionAlongSpline) == 0x00001C, "Wrong size on PhxSpline_GetDirectionAlongSpline");
static_assert(offsetof(PhxSpline_GetDirectionAlongSpline, Distance) == 0x000000, "Member 'PhxSpline_GetDirectionAlongSpline::Distance' has a wrong offset!");
static_assert(offsetof(PhxSpline_GetDirectionAlongSpline, Axis) == 0x000004, "Member 'PhxSpline_GetDirectionAlongSpline::Axis' has a wrong offset!");
static_assert(offsetof(PhxSpline_GetDirectionAlongSpline, ReturnValue) == 0x000010, "Member 'PhxSpline_GetDirectionAlongSpline::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSpline.GetEndpoints
// 0x0060 (0x0060 - 0x0000)
struct PhxSpline_GetEndpoints final
{
public:
	struct FTransform                             Start;                                             // 0x0000(0x0030)(Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FTransform                             End;                                               // 0x0030(0x0030)(Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSpline_GetEndpoints) == 0x000010, "Wrong alignment on PhxSpline_GetEndpoints");
static_assert(sizeof(PhxSpline_GetEndpoints) == 0x000060, "Wrong size on PhxSpline_GetEndpoints");
static_assert(offsetof(PhxSpline_GetEndpoints, Start) == 0x000000, "Member 'PhxSpline_GetEndpoints::Start' has a wrong offset!");
static_assert(offsetof(PhxSpline_GetEndpoints, End) == 0x000030, "Member 'PhxSpline_GetEndpoints::End' has a wrong offset!");

// Function Phoenix.PhxSpline.GetInteractableComponent
// 0x0010 (0x0010 - 0x0000)
struct PhxSpline_GetInteractableComponent final
{
public:
	ESplineEnd                                    End;                                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UInteractableComponent*                 ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSpline_GetInteractableComponent) == 0x000008, "Wrong alignment on PhxSpline_GetInteractableComponent");
static_assert(sizeof(PhxSpline_GetInteractableComponent) == 0x000010, "Wrong size on PhxSpline_GetInteractableComponent");
static_assert(offsetof(PhxSpline_GetInteractableComponent, End) == 0x000000, "Member 'PhxSpline_GetInteractableComponent::End' has a wrong offset!");
static_assert(offsetof(PhxSpline_GetInteractableComponent, ReturnValue) == 0x000008, "Member 'PhxSpline_GetInteractableComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSpline.GetNearesetEnd
// 0x0010 (0x0010 - 0x0000)
struct PhxSpline_GetNearesetEnd final
{
public:
	struct FVector                                WorldVector;                                       // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESplineEnd                                    ReturnValue;                                       // 0x000C(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSpline_GetNearesetEnd) == 0x000004, "Wrong alignment on PhxSpline_GetNearesetEnd");
static_assert(sizeof(PhxSpline_GetNearesetEnd) == 0x000010, "Wrong size on PhxSpline_GetNearesetEnd");
static_assert(offsetof(PhxSpline_GetNearesetEnd, WorldVector) == 0x000000, "Member 'PhxSpline_GetNearesetEnd::WorldVector' has a wrong offset!");
static_assert(offsetof(PhxSpline_GetNearesetEnd, ReturnValue) == 0x00000C, "Member 'PhxSpline_GetNearesetEnd::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSpline.GetPositionAlongSpline
// 0x0010 (0x0010 - 0x0000)
struct PhxSpline_GetPositionAlongSpline final
{
public:
	float                                         Distance;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x0004(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSpline_GetPositionAlongSpline) == 0x000004, "Wrong alignment on PhxSpline_GetPositionAlongSpline");
static_assert(sizeof(PhxSpline_GetPositionAlongSpline) == 0x000010, "Wrong size on PhxSpline_GetPositionAlongSpline");
static_assert(offsetof(PhxSpline_GetPositionAlongSpline, Distance) == 0x000000, "Member 'PhxSpline_GetPositionAlongSpline::Distance' has a wrong offset!");
static_assert(offsetof(PhxSpline_GetPositionAlongSpline, ReturnValue) == 0x000004, "Member 'PhxSpline_GetPositionAlongSpline::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSpline.GetRotationAlongSpline
// 0x0010 (0x0010 - 0x0000)
struct PhxSpline_GetRotationAlongSpline final
{
public:
	float                                         Distance;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               ReturnValue;                                       // 0x0004(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSpline_GetRotationAlongSpline) == 0x000004, "Wrong alignment on PhxSpline_GetRotationAlongSpline");
static_assert(sizeof(PhxSpline_GetRotationAlongSpline) == 0x000010, "Wrong size on PhxSpline_GetRotationAlongSpline");
static_assert(offsetof(PhxSpline_GetRotationAlongSpline, Distance) == 0x000000, "Member 'PhxSpline_GetRotationAlongSpline::Distance' has a wrong offset!");
static_assert(offsetof(PhxSpline_GetRotationAlongSpline, ReturnValue) == 0x000004, "Member 'PhxSpline_GetRotationAlongSpline::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSpline.GetSplineLength
// 0x0004 (0x0004 - 0x0000)
struct PhxSpline_GetSplineLength final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSpline_GetSplineLength) == 0x000004, "Wrong alignment on PhxSpline_GetSplineLength");
static_assert(sizeof(PhxSpline_GetSplineLength) == 0x000004, "Wrong size on PhxSpline_GetSplineLength");
static_assert(offsetof(PhxSpline_GetSplineLength, ReturnValue) == 0x000000, "Member 'PhxSpline_GetSplineLength::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDanglerTunnel.PlaySpawningParticleFX
// 0x0008 (0x0008 - 0x0000)
struct PhxDanglerTunnel_PlaySpawningParticleFX final
{
public:
	class UNiagaraSystem*                         ParticleSystem;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDanglerTunnel_PlaySpawningParticleFX) == 0x000008, "Wrong alignment on PhxDanglerTunnel_PlaySpawningParticleFX");
static_assert(sizeof(PhxDanglerTunnel_PlaySpawningParticleFX) == 0x000008, "Wrong size on PhxDanglerTunnel_PlaySpawningParticleFX");
static_assert(offsetof(PhxDanglerTunnel_PlaySpawningParticleFX, ParticleSystem) == 0x000000, "Member 'PhxDanglerTunnel_PlaySpawningParticleFX::ParticleSystem' has a wrong offset!");

// Function Phoenix.PhxDanglerTunnel.SpawnAttackDangler
// 0x0008 (0x0008 - 0x0000)
struct PhxDanglerTunnel_SpawnAttackDangler final
{
public:
	class UPhxAISpawnerComponent*                 Spawner;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDanglerTunnel_SpawnAttackDangler) == 0x000008, "Wrong alignment on PhxDanglerTunnel_SpawnAttackDangler");
static_assert(sizeof(PhxDanglerTunnel_SpawnAttackDangler) == 0x000008, "Wrong size on PhxDanglerTunnel_SpawnAttackDangler");
static_assert(offsetof(PhxDanglerTunnel_SpawnAttackDangler, Spawner) == 0x000000, "Member 'PhxDanglerTunnel_SpawnAttackDangler::Spawner' has a wrong offset!");

// Function Phoenix.PhxDanglerTunnel.StartCrawlingParticleFX
// 0x0008 (0x0008 - 0x0000)
struct PhxDanglerTunnel_StartCrawlingParticleFX final
{
public:
	class UNiagaraSystem*                         ParticleSystem;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDanglerTunnel_StartCrawlingParticleFX) == 0x000008, "Wrong alignment on PhxDanglerTunnel_StartCrawlingParticleFX");
static_assert(sizeof(PhxDanglerTunnel_StartCrawlingParticleFX) == 0x000008, "Wrong size on PhxDanglerTunnel_StartCrawlingParticleFX");
static_assert(offsetof(PhxDanglerTunnel_StartCrawlingParticleFX, ParticleSystem) == 0x000000, "Member 'PhxDanglerTunnel_StartCrawlingParticleFX::ParticleSystem' has a wrong offset!");

// Function Phoenix.PhxDanglerTunnel.GetNormalizedLocationAndRotation
// 0x001C (0x001C - 0x0000)
struct PhxDanglerTunnel_GetNormalizedLocationAndRotation final
{
public:
	float                                         NormalizedLocation;                                // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                OutLocation;                                       // 0x0004(0x000C)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               OutRotation;                                       // 0x0010(0x000C)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDanglerTunnel_GetNormalizedLocationAndRotation) == 0x000004, "Wrong alignment on PhxDanglerTunnel_GetNormalizedLocationAndRotation");
static_assert(sizeof(PhxDanglerTunnel_GetNormalizedLocationAndRotation) == 0x00001C, "Wrong size on PhxDanglerTunnel_GetNormalizedLocationAndRotation");
static_assert(offsetof(PhxDanglerTunnel_GetNormalizedLocationAndRotation, NormalizedLocation) == 0x000000, "Member 'PhxDanglerTunnel_GetNormalizedLocationAndRotation::NormalizedLocation' has a wrong offset!");
static_assert(offsetof(PhxDanglerTunnel_GetNormalizedLocationAndRotation, OutLocation) == 0x000004, "Member 'PhxDanglerTunnel_GetNormalizedLocationAndRotation::OutLocation' has a wrong offset!");
static_assert(offsetof(PhxDanglerTunnel_GetNormalizedLocationAndRotation, OutRotation) == 0x000010, "Member 'PhxDanglerTunnel_GetNormalizedLocationAndRotation::OutRotation' has a wrong offset!");

// Function Phoenix.PhxDanglerTunnel.IsPlayerFlashlightAimedAtDangler
// 0x0010 (0x0010 - 0x0000)
struct PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler final
{
public:
	const class APhxAICharacter*                  Dangler;                                           // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler) == 0x000008, "Wrong alignment on PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler");
static_assert(sizeof(PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler) == 0x000010, "Wrong size on PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler");
static_assert(offsetof(PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler, Dangler) == 0x000000, "Member 'PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler::Dangler' has a wrong offset!");
static_assert(offsetof(PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler, ReturnValue) == 0x000008, "Member 'PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler::ReturnValue' has a wrong offset!");

// Function Phoenix.ChargedGroundSlamComponent.GetChargeLevel
// 0x0008 (0x0008 - 0x0000)
struct ChargedGroundSlamComponent_GetChargeLevel final
{
public:
	float                                         ChargeHoldTime;                                    // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ChargedGroundSlamComponent_GetChargeLevel) == 0x000004, "Wrong alignment on ChargedGroundSlamComponent_GetChargeLevel");
static_assert(sizeof(ChargedGroundSlamComponent_GetChargeLevel) == 0x000008, "Wrong size on ChargedGroundSlamComponent_GetChargeLevel");
static_assert(offsetof(ChargedGroundSlamComponent_GetChargeLevel, ChargeHoldTime) == 0x000000, "Member 'ChargedGroundSlamComponent_GetChargeLevel::ChargeHoldTime' has a wrong offset!");
static_assert(offsetof(ChargedGroundSlamComponent_GetChargeLevel, ReturnValue) == 0x000004, "Member 'ChargedGroundSlamComponent_GetChargeLevel::ReturnValue' has a wrong offset!");

// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamCrateDamageTypeClass
// 0x0008 (0x0008 - 0x0000)
struct ChargedGroundSlamComponent_GetGroundSlamCrateDamageTypeClass final
{
public:
	TSubclassOf<class UDamageType>                ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ChargedGroundSlamComponent_GetGroundSlamCrateDamageTypeClass) == 0x000008, "Wrong alignment on ChargedGroundSlamComponent_GetGroundSlamCrateDamageTypeClass");
static_assert(sizeof(ChargedGroundSlamComponent_GetGroundSlamCrateDamageTypeClass) == 0x000008, "Wrong size on ChargedGroundSlamComponent_GetGroundSlamCrateDamageTypeClass");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamCrateDamageTypeClass, ReturnValue) == 0x000000, "Member 'ChargedGroundSlamComponent_GetGroundSlamCrateDamageTypeClass::ReturnValue' has a wrong offset!");

// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamCratesDamage
// 0x0004 (0x0004 - 0x0000)
struct ChargedGroundSlamComponent_GetGroundSlamCratesDamage final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ChargedGroundSlamComponent_GetGroundSlamCratesDamage) == 0x000004, "Wrong alignment on ChargedGroundSlamComponent_GetGroundSlamCratesDamage");
static_assert(sizeof(ChargedGroundSlamComponent_GetGroundSlamCratesDamage) == 0x000004, "Wrong size on ChargedGroundSlamComponent_GetGroundSlamCratesDamage");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamCratesDamage, ReturnValue) == 0x000000, "Member 'ChargedGroundSlamComponent_GetGroundSlamCratesDamage::ReturnValue' has a wrong offset!");

// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamCratesDamageRange
// 0x0004 (0x0004 - 0x0000)
struct ChargedGroundSlamComponent_GetGroundSlamCratesDamageRange final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ChargedGroundSlamComponent_GetGroundSlamCratesDamageRange) == 0x000004, "Wrong alignment on ChargedGroundSlamComponent_GetGroundSlamCratesDamageRange");
static_assert(sizeof(ChargedGroundSlamComponent_GetGroundSlamCratesDamageRange) == 0x000004, "Wrong size on ChargedGroundSlamComponent_GetGroundSlamCratesDamageRange");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamCratesDamageRange, ReturnValue) == 0x000000, "Member 'ChargedGroundSlamComponent_GetGroundSlamCratesDamageRange::ReturnValue' has a wrong offset!");

// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamDamageMultiplier
// 0x0008 (0x0008 - 0x0000)
struct ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier final
{
public:
	float                                         ChargeHoldTime;                                    // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier) == 0x000004, "Wrong alignment on ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier");
static_assert(sizeof(ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier) == 0x000008, "Wrong size on ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier, ChargeHoldTime) == 0x000000, "Member 'ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier::ChargeHoldTime' has a wrong offset!");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier, ReturnValue) == 0x000004, "Member 'ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier::ReturnValue' has a wrong offset!");

// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamDamageTypeClass
// 0x0010 (0x0010 - 0x0000)
struct ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass final
{
public:
	float                                         ChargeHoldTime;                                    // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UDamageType>                ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass) == 0x000008, "Wrong alignment on ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass");
static_assert(sizeof(ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass) == 0x000010, "Wrong size on ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass, ChargeHoldTime) == 0x000000, "Member 'ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass::ChargeHoldTime' has a wrong offset!");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass, ReturnValue) == 0x000008, "Member 'ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass::ReturnValue' has a wrong offset!");

// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamDebugDuration
// 0x0004 (0x0004 - 0x0000)
struct ChargedGroundSlamComponent_GetGroundSlamDebugDuration final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ChargedGroundSlamComponent_GetGroundSlamDebugDuration) == 0x000004, "Wrong alignment on ChargedGroundSlamComponent_GetGroundSlamDebugDuration");
static_assert(sizeof(ChargedGroundSlamComponent_GetGroundSlamDebugDuration) == 0x000004, "Wrong size on ChargedGroundSlamComponent_GetGroundSlamDebugDuration");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamDebugDuration, ReturnValue) == 0x000000, "Member 'ChargedGroundSlamComponent_GetGroundSlamDebugDuration::ReturnValue' has a wrong offset!");

// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamRangeMultiplier
// 0x0008 (0x0008 - 0x0000)
struct ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier final
{
public:
	float                                         ChargeHoldTime;                                    // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier) == 0x000004, "Wrong alignment on ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier");
static_assert(sizeof(ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier) == 0x000008, "Wrong size on ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier, ChargeHoldTime) == 0x000000, "Member 'ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier::ChargeHoldTime' has a wrong offset!");
static_assert(offsetof(ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier, ReturnValue) == 0x000004, "Member 'ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWeaponModification.ApplyChanges
// 0x0008 (0x0008 - 0x0000)
struct PhxWeaponModification_ApplyChanges final
{
public:
	class AWeapon*                                Weapon;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponModification_ApplyChanges) == 0x000008, "Wrong alignment on PhxWeaponModification_ApplyChanges");
static_assert(sizeof(PhxWeaponModification_ApplyChanges) == 0x000008, "Wrong size on PhxWeaponModification_ApplyChanges");
static_assert(offsetof(PhxWeaponModification_ApplyChanges, Weapon) == 0x000000, "Member 'PhxWeaponModification_ApplyChanges::Weapon' has a wrong offset!");

// Function Phoenix.PhxWeaponModification.OnEquip
// 0x0008 (0x0008 - 0x0000)
struct PhxWeaponModification_OnEquip final
{
public:
	class AWeapon*                                Weapon;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponModification_OnEquip) == 0x000008, "Wrong alignment on PhxWeaponModification_OnEquip");
static_assert(sizeof(PhxWeaponModification_OnEquip) == 0x000008, "Wrong size on PhxWeaponModification_OnEquip");
static_assert(offsetof(PhxWeaponModification_OnEquip, Weapon) == 0x000000, "Member 'PhxWeaponModification_OnEquip::Weapon' has a wrong offset!");

// Function Phoenix.PhxWeaponModification.OnUnequip
// 0x0008 (0x0008 - 0x0000)
struct PhxWeaponModification_OnUnequip final
{
public:
	class AWeapon*                                Weapon;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponModification_OnUnequip) == 0x000008, "Wrong alignment on PhxWeaponModification_OnUnequip");
static_assert(sizeof(PhxWeaponModification_OnUnequip) == 0x000008, "Wrong size on PhxWeaponModification_OnUnequip");
static_assert(offsetof(PhxWeaponModification_OnUnequip, Weapon) == 0x000000, "Member 'PhxWeaponModification_OnUnequip::Weapon' has a wrong offset!");

// Function Phoenix.PhxWeaponModification.UndoChanges
// 0x0008 (0x0008 - 0x0000)
struct PhxWeaponModification_UndoChanges final
{
public:
	class AWeapon*                                Weapon;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponModification_UndoChanges) == 0x000008, "Wrong alignment on PhxWeaponModification_UndoChanges");
static_assert(sizeof(PhxWeaponModification_UndoChanges) == 0x000008, "Wrong size on PhxWeaponModification_UndoChanges");
static_assert(offsetof(PhxWeaponModification_UndoChanges, Weapon) == 0x000000, "Member 'PhxWeaponModification_UndoChanges::Weapon' has a wrong offset!");

// Function Phoenix.PhxWeaponModification.GetAssetToLoad
// 0x0020 (0x0020 - 0x0000)
struct PhxWeaponModification_GetAssetToLoad final
{
public:
	class AWeapon*                                Weapon;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        ReturnValue;                                       // 0x0008(0x0018)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponModification_GetAssetToLoad) == 0x000008, "Wrong alignment on PhxWeaponModification_GetAssetToLoad");
static_assert(sizeof(PhxWeaponModification_GetAssetToLoad) == 0x000020, "Wrong size on PhxWeaponModification_GetAssetToLoad");
static_assert(offsetof(PhxWeaponModification_GetAssetToLoad, Weapon) == 0x000000, "Member 'PhxWeaponModification_GetAssetToLoad::Weapon' has a wrong offset!");
static_assert(offsetof(PhxWeaponModification_GetAssetToLoad, ReturnValue) == 0x000008, "Member 'PhxWeaponModification_GetAssetToLoad::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMaterialWeaponMod.GetDynamicMaterialInstance
// 0x0010 (0x0010 - 0x0000)
struct PhxMaterialWeaponMod_GetDynamicMaterialInstance final
{
public:
	class AWeapon*                                Weapon;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMaterialWeaponMod_GetDynamicMaterialInstance) == 0x000008, "Wrong alignment on PhxMaterialWeaponMod_GetDynamicMaterialInstance");
static_assert(sizeof(PhxMaterialWeaponMod_GetDynamicMaterialInstance) == 0x000010, "Wrong size on PhxMaterialWeaponMod_GetDynamicMaterialInstance");
static_assert(offsetof(PhxMaterialWeaponMod_GetDynamicMaterialInstance, Weapon) == 0x000000, "Member 'PhxMaterialWeaponMod_GetDynamicMaterialInstance::Weapon' has a wrong offset!");
static_assert(offsetof(PhxMaterialWeaponMod_GetDynamicMaterialInstance, ReturnValue) == 0x000008, "Member 'PhxMaterialWeaponMod_GetDynamicMaterialInstance::ReturnValue' has a wrong offset!");

// Function Phoenix.Checkpoint.CheckpointReached
// 0x0010 (0x0010 - 0x0000)
struct Checkpoint_CheckpointReached final
{
public:
	class APhxPlayerCharacter*                    Player;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForce;                                            // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(Checkpoint_CheckpointReached) == 0x000008, "Wrong alignment on Checkpoint_CheckpointReached");
static_assert(sizeof(Checkpoint_CheckpointReached) == 0x000010, "Wrong size on Checkpoint_CheckpointReached");
static_assert(offsetof(Checkpoint_CheckpointReached, Player) == 0x000000, "Member 'Checkpoint_CheckpointReached::Player' has a wrong offset!");
static_assert(offsetof(Checkpoint_CheckpointReached, bForce) == 0x000008, "Member 'Checkpoint_CheckpointReached::bForce' has a wrong offset!");

// Function Phoenix.Checkpoint.OnBeginOverlap
// 0x0010 (0x0010 - 0x0000)
struct Checkpoint_OnBeginOverlap final
{
public:
	class AActor*                                 MyActor;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Checkpoint_OnBeginOverlap) == 0x000008, "Wrong alignment on Checkpoint_OnBeginOverlap");
static_assert(sizeof(Checkpoint_OnBeginOverlap) == 0x000010, "Wrong size on Checkpoint_OnBeginOverlap");
static_assert(offsetof(Checkpoint_OnBeginOverlap, MyActor) == 0x000000, "Member 'Checkpoint_OnBeginOverlap::MyActor' has a wrong offset!");
static_assert(offsetof(Checkpoint_OnBeginOverlap, OtherActor) == 0x000008, "Member 'Checkpoint_OnBeginOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.Checkpoint.OnCompanionSpawned
// 0x0010 (0x0010 - 0x0000)
struct Checkpoint_OnCompanionSpawned final
{
public:
	class APhxAICharacter*                        SpawnedAI;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAISpawnResultCode                         ResultCode;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SpawnUid;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Checkpoint_OnCompanionSpawned) == 0x000008, "Wrong alignment on Checkpoint_OnCompanionSpawned");
static_assert(sizeof(Checkpoint_OnCompanionSpawned) == 0x000010, "Wrong size on Checkpoint_OnCompanionSpawned");
static_assert(offsetof(Checkpoint_OnCompanionSpawned, SpawnedAI) == 0x000000, "Member 'Checkpoint_OnCompanionSpawned::SpawnedAI' has a wrong offset!");
static_assert(offsetof(Checkpoint_OnCompanionSpawned, ResultCode) == 0x000008, "Member 'Checkpoint_OnCompanionSpawned::ResultCode' has a wrong offset!");
static_assert(offsetof(Checkpoint_OnCompanionSpawned, SpawnUid) == 0x00000C, "Member 'Checkpoint_OnCompanionSpawned::SpawnUid' has a wrong offset!");

// Function Phoenix.Checkpoint.GetCheckpointId
// 0x0008 (0x0008 - 0x0000)
struct Checkpoint_GetCheckpointId final
{
public:
	class FName                                   ReturnValue;                                       // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Checkpoint_GetCheckpointId) == 0x000004, "Wrong alignment on Checkpoint_GetCheckpointId");
static_assert(sizeof(Checkpoint_GetCheckpointId) == 0x000008, "Wrong size on Checkpoint_GetCheckpointId");
static_assert(offsetof(Checkpoint_GetCheckpointId, ReturnValue) == 0x000000, "Member 'Checkpoint_GetCheckpointId::ReturnValue' has a wrong offset!");

// Function Phoenix.Checkpoint.IsCheckpointEnabled
// 0x0001 (0x0001 - 0x0000)
struct Checkpoint_IsCheckpointEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Checkpoint_IsCheckpointEnabled) == 0x000001, "Wrong alignment on Checkpoint_IsCheckpointEnabled");
static_assert(sizeof(Checkpoint_IsCheckpointEnabled) == 0x000001, "Wrong size on Checkpoint_IsCheckpointEnabled");
static_assert(offsetof(Checkpoint_IsCheckpointEnabled, ReturnValue) == 0x000000, "Member 'Checkpoint_IsCheckpointEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.MotionMatchCostTest.CancelTest
// 0x0001 (0x0001 - 0x0000)
struct MotionMatchCostTest_CancelTest final
{
public:
	bool                                          bWasCompleted;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MotionMatchCostTest_CancelTest) == 0x000001, "Wrong alignment on MotionMatchCostTest_CancelTest");
static_assert(sizeof(MotionMatchCostTest_CancelTest) == 0x000001, "Wrong size on MotionMatchCostTest_CancelTest");
static_assert(offsetof(MotionMatchCostTest_CancelTest, bWasCompleted) == 0x000000, "Member 'MotionMatchCostTest_CancelTest::bWasCompleted' has a wrong offset!");

// Function Phoenix.MotionMatchCostTest.CollectCost
// 0x0004 (0x0004 - 0x0000)
struct MotionMatchCostTest_CollectCost final
{
public:
	float                                         AvgCost;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MotionMatchCostTest_CollectCost) == 0x000004, "Wrong alignment on MotionMatchCostTest_CollectCost");
static_assert(sizeof(MotionMatchCostTest_CollectCost) == 0x000004, "Wrong size on MotionMatchCostTest_CollectCost");
static_assert(offsetof(MotionMatchCostTest_CollectCost, AvgCost) == 0x000000, "Member 'MotionMatchCostTest_CollectCost::AvgCost' has a wrong offset!");

// Function Phoenix.MotionMatchCostTest.ExecuteTest
// 0x0003 (0x0003 - 0x0000)
struct MotionMatchCostTest_ExecuteTest final
{
public:
	EMotionMatchTestAI                            ChosenSubtestAI;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMotionMatchTestMotion                        ChosenSubtestMotion;                               // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMotionMatchTestMovement                      ChosenSubtestMovement;                             // 0x0002(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MotionMatchCostTest_ExecuteTest) == 0x000001, "Wrong alignment on MotionMatchCostTest_ExecuteTest");
static_assert(sizeof(MotionMatchCostTest_ExecuteTest) == 0x000003, "Wrong size on MotionMatchCostTest_ExecuteTest");
static_assert(offsetof(MotionMatchCostTest_ExecuteTest, ChosenSubtestAI) == 0x000000, "Member 'MotionMatchCostTest_ExecuteTest::ChosenSubtestAI' has a wrong offset!");
static_assert(offsetof(MotionMatchCostTest_ExecuteTest, ChosenSubtestMotion) == 0x000001, "Member 'MotionMatchCostTest_ExecuteTest::ChosenSubtestMotion' has a wrong offset!");
static_assert(offsetof(MotionMatchCostTest_ExecuteTest, ChosenSubtestMovement) == 0x000002, "Member 'MotionMatchCostTest_ExecuteTest::ChosenSubtestMovement' has a wrong offset!");

// Function Phoenix.MotionMatchCostTest.SaveTestResults
// 0x0028 (0x0028 - 0x0000)
struct MotionMatchCostTest_SaveTestResults final
{
public:
	class FString                                 SaveDirectory;                                     // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Filename;                                          // 0x0010(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          AllowOverWriting;                                  // 0x0020(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0021(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_22[0x6];                                       // 0x0022(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(MotionMatchCostTest_SaveTestResults) == 0x000008, "Wrong alignment on MotionMatchCostTest_SaveTestResults");
static_assert(sizeof(MotionMatchCostTest_SaveTestResults) == 0x000028, "Wrong size on MotionMatchCostTest_SaveTestResults");
static_assert(offsetof(MotionMatchCostTest_SaveTestResults, SaveDirectory) == 0x000000, "Member 'MotionMatchCostTest_SaveTestResults::SaveDirectory' has a wrong offset!");
static_assert(offsetof(MotionMatchCostTest_SaveTestResults, Filename) == 0x000010, "Member 'MotionMatchCostTest_SaveTestResults::Filename' has a wrong offset!");
static_assert(offsetof(MotionMatchCostTest_SaveTestResults, AllowOverWriting) == 0x000020, "Member 'MotionMatchCostTest_SaveTestResults::AllowOverWriting' has a wrong offset!");
static_assert(offsetof(MotionMatchCostTest_SaveTestResults, ReturnValue) == 0x000021, "Member 'MotionMatchCostTest_SaveTestResults::ReturnValue' has a wrong offset!");

// Function Phoenix.MotionMatchCostTest.SetCostRetriever
// 0x0008 (0x0008 - 0x0000)
struct MotionMatchCostTest_SetCostRetriever final
{
public:
	class UMotionMatchCostRetriever*              Retriever;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MotionMatchCostTest_SetCostRetriever) == 0x000008, "Wrong alignment on MotionMatchCostTest_SetCostRetriever");
static_assert(sizeof(MotionMatchCostTest_SetCostRetriever) == 0x000008, "Wrong size on MotionMatchCostTest_SetCostRetriever");
static_assert(offsetof(MotionMatchCostTest_SetCostRetriever, Retriever) == 0x000000, "Member 'MotionMatchCostTest_SetCostRetriever::Retriever' has a wrong offset!");

// Function Phoenix.PhxAmbienceManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxAmbienceManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAmbienceManager*                    ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAmbienceManager_Get) == 0x000008, "Wrong alignment on PhxAmbienceManager_Get");
static_assert(sizeof(PhxAmbienceManager_Get) == 0x000010, "Wrong size on PhxAmbienceManager_Get");
static_assert(offsetof(PhxAmbienceManager_Get, WorldContextObject) == 0x000000, "Member 'PhxAmbienceManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAmbienceManager_Get, ReturnValue) == 0x000008, "Member 'PhxAmbienceManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAmbienceManager.EnterAmbientRegion
// 0x0008 (0x0008 - 0x0000)
struct PhxAmbienceManager_EnterAmbientRegion final
{
public:
	class AAmbientRegion*                         AmbientRegion;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAmbienceManager_EnterAmbientRegion) == 0x000008, "Wrong alignment on PhxAmbienceManager_EnterAmbientRegion");
static_assert(sizeof(PhxAmbienceManager_EnterAmbientRegion) == 0x000008, "Wrong size on PhxAmbienceManager_EnterAmbientRegion");
static_assert(offsetof(PhxAmbienceManager_EnterAmbientRegion, AmbientRegion) == 0x000000, "Member 'PhxAmbienceManager_EnterAmbientRegion::AmbientRegion' has a wrong offset!");

// Function Phoenix.PhxAmbienceManager.ExitAmbientRegion
// 0x0008 (0x0008 - 0x0000)
struct PhxAmbienceManager_ExitAmbientRegion final
{
public:
	class AAmbientRegion*                         AmbientRegion;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAmbienceManager_ExitAmbientRegion) == 0x000008, "Wrong alignment on PhxAmbienceManager_ExitAmbientRegion");
static_assert(sizeof(PhxAmbienceManager_ExitAmbientRegion) == 0x000008, "Wrong size on PhxAmbienceManager_ExitAmbientRegion");
static_assert(offsetof(PhxAmbienceManager_ExitAmbientRegion, AmbientRegion) == 0x000000, "Member 'PhxAmbienceManager_ExitAmbientRegion::AmbientRegion' has a wrong offset!");

// Function Phoenix.InventoryDetails.ApplyVID
// 0x0008 (0x0008 - 0x0000)
struct InventoryDetails_ApplyVID final
{
public:
	const class UVirtualItemData*                 InVID;                                             // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryDetails_ApplyVID) == 0x000008, "Wrong alignment on InventoryDetails_ApplyVID");
static_assert(sizeof(InventoryDetails_ApplyVID) == 0x000008, "Wrong size on InventoryDetails_ApplyVID");
static_assert(offsetof(InventoryDetails_ApplyVID, InVID) == 0x000000, "Member 'InventoryDetails_ApplyVID::InVID' has a wrong offset!");

// Function Phoenix.InventoryDetails.SetFocused
// 0x0001 (0x0001 - 0x0000)
struct InventoryDetails_SetFocused final
{
public:
	bool                                          bInFocused;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryDetails_SetFocused) == 0x000001, "Wrong alignment on InventoryDetails_SetFocused");
static_assert(sizeof(InventoryDetails_SetFocused) == 0x000001, "Wrong size on InventoryDetails_SetFocused");
static_assert(offsetof(InventoryDetails_SetFocused, bInFocused) == 0x000000, "Member 'InventoryDetails_SetFocused::bInFocused' has a wrong offset!");

// Function Phoenix.InventoryDetails.SetItemDetails
// 0x0100 (0x0100 - 0x0000)
struct InventoryDetails_SetItemDetails final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryDetails_SetItemDetails) == 0x000008, "Wrong alignment on InventoryDetails_SetItemDetails");
static_assert(sizeof(InventoryDetails_SetItemDetails) == 0x000100, "Wrong size on InventoryDetails_SetItemDetails");
static_assert(offsetof(InventoryDetails_SetItemDetails, InItem) == 0x000000, "Member 'InventoryDetails_SetItemDetails::InItem' has a wrong offset!");

// Function Phoenix.InventoryDetails.IsFocused
// 0x0001 (0x0001 - 0x0000)
struct InventoryDetails_IsFocused final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryDetails_IsFocused) == 0x000001, "Wrong alignment on InventoryDetails_IsFocused");
static_assert(sizeof(InventoryDetails_IsFocused) == 0x000001, "Wrong size on InventoryDetails_IsFocused");
static_assert(offsetof(InventoryDetails_IsFocused, ReturnValue) == 0x000000, "Member 'InventoryDetails_IsFocused::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawningSystem.DespawnAI
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawningSystem_DespawnAI final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIDespawnReason                           Reason;                                            // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnemiesOnly;                                      // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAISpawningSystem_DespawnAI) == 0x000008, "Wrong alignment on PhxAISpawningSystem_DespawnAI");
static_assert(sizeof(PhxAISpawningSystem_DespawnAI) == 0x000010, "Wrong size on PhxAISpawningSystem_DespawnAI");
static_assert(offsetof(PhxAISpawningSystem_DespawnAI, WorldContextObject) == 0x000000, "Member 'PhxAISpawningSystem_DespawnAI::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAISpawningSystem_DespawnAI, Reason) == 0x000008, "Member 'PhxAISpawningSystem_DespawnAI::Reason' has a wrong offset!");
static_assert(offsetof(PhxAISpawningSystem_DespawnAI, bEnemiesOnly) == 0x000009, "Member 'PhxAISpawningSystem_DespawnAI::bEnemiesOnly' has a wrong offset!");

// Function Phoenix.PhxAISpawningSystem.DespawnAICharacter
// 0x0018 (0x0018 - 0x0000)
struct PhxAISpawningSystem_DespawnAICharacter final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIDespawnReason                           Reason;                                            // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAISpawningSystem_DespawnAICharacter) == 0x000008, "Wrong alignment on PhxAISpawningSystem_DespawnAICharacter");
static_assert(sizeof(PhxAISpawningSystem_DespawnAICharacter) == 0x000018, "Wrong size on PhxAISpawningSystem_DespawnAICharacter");
static_assert(offsetof(PhxAISpawningSystem_DespawnAICharacter, WorldContextObject) == 0x000000, "Member 'PhxAISpawningSystem_DespawnAICharacter::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAISpawningSystem_DespawnAICharacter, Character) == 0x000008, "Member 'PhxAISpawningSystem_DespawnAICharacter::Character' has a wrong offset!");
static_assert(offsetof(PhxAISpawningSystem_DespawnAICharacter, Reason) == 0x000010, "Member 'PhxAISpawningSystem_DespawnAICharacter::Reason' has a wrong offset!");

// Function Phoenix.OptionsWidget.SetSelection
// 0x0008 (0x0008 - 0x0000)
struct OptionsWidget_SetSelection final
{
public:
	int32                                         ButtonIndex;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsRight;                                          // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bPlayAnimation;                                    // 0x0005(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6[0x2];                                        // 0x0006(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(OptionsWidget_SetSelection) == 0x000004, "Wrong alignment on OptionsWidget_SetSelection");
static_assert(sizeof(OptionsWidget_SetSelection) == 0x000008, "Wrong size on OptionsWidget_SetSelection");
static_assert(offsetof(OptionsWidget_SetSelection, ButtonIndex) == 0x000000, "Member 'OptionsWidget_SetSelection::ButtonIndex' has a wrong offset!");
static_assert(offsetof(OptionsWidget_SetSelection, bIsRight) == 0x000004, "Member 'OptionsWidget_SetSelection::bIsRight' has a wrong offset!");
static_assert(offsetof(OptionsWidget_SetSelection, bPlayAnimation) == 0x000005, "Member 'OptionsWidget_SetSelection::bPlayAnimation' has a wrong offset!");

// Function Phoenix.PhxAIPointOfInterest.GetBlackboardValue
// 0x0010 (0x0010 - 0x0000)
struct PhxAIPointOfInterest_GetBlackboardValue final
{
public:
	int32                                         idx;                                               // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAIBlackboardValue_Base*             ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIPointOfInterest_GetBlackboardValue) == 0x000008, "Wrong alignment on PhxAIPointOfInterest_GetBlackboardValue");
static_assert(sizeof(PhxAIPointOfInterest_GetBlackboardValue) == 0x000010, "Wrong size on PhxAIPointOfInterest_GetBlackboardValue");
static_assert(offsetof(PhxAIPointOfInterest_GetBlackboardValue, idx) == 0x000000, "Member 'PhxAIPointOfInterest_GetBlackboardValue::idx' has a wrong offset!");
static_assert(offsetof(PhxAIPointOfInterest_GetBlackboardValue, ReturnValue) == 0x000008, "Member 'PhxAIPointOfInterest_GetBlackboardValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIPointOfInterest.GetBlackboardValuesCount
// 0x0004 (0x0004 - 0x0000)
struct PhxAIPointOfInterest_GetBlackboardValuesCount final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIPointOfInterest_GetBlackboardValuesCount) == 0x000004, "Wrong alignment on PhxAIPointOfInterest_GetBlackboardValuesCount");
static_assert(sizeof(PhxAIPointOfInterest_GetBlackboardValuesCount) == 0x000004, "Wrong size on PhxAIPointOfInterest_GetBlackboardValuesCount");
static_assert(offsetof(PhxAIPointOfInterest_GetBlackboardValuesCount, ReturnValue) == 0x000000, "Member 'PhxAIPointOfInterest_GetBlackboardValuesCount::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryFSM.OnCharacterHealthModified
// 0x0028 (0x0028 - 0x0000)
struct InventoryFSM_OnCharacterHealthModified final
{
public:
	class UPhxHealthComponent*                    HealthComp;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HealthDelta;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryFSM_OnCharacterHealthModified) == 0x000008, "Wrong alignment on InventoryFSM_OnCharacterHealthModified");
static_assert(sizeof(InventoryFSM_OnCharacterHealthModified) == 0x000028, "Wrong size on InventoryFSM_OnCharacterHealthModified");
static_assert(offsetof(InventoryFSM_OnCharacterHealthModified, HealthComp) == 0x000000, "Member 'InventoryFSM_OnCharacterHealthModified::HealthComp' has a wrong offset!");
static_assert(offsetof(InventoryFSM_OnCharacterHealthModified, Health) == 0x000008, "Member 'InventoryFSM_OnCharacterHealthModified::Health' has a wrong offset!");
static_assert(offsetof(InventoryFSM_OnCharacterHealthModified, HealthDelta) == 0x00000C, "Member 'InventoryFSM_OnCharacterHealthModified::HealthDelta' has a wrong offset!");
static_assert(offsetof(InventoryFSM_OnCharacterHealthModified, DamageType) == 0x000010, "Member 'InventoryFSM_OnCharacterHealthModified::DamageType' has a wrong offset!");
static_assert(offsetof(InventoryFSM_OnCharacterHealthModified, InstigatedBy) == 0x000018, "Member 'InventoryFSM_OnCharacterHealthModified::InstigatedBy' has a wrong offset!");
static_assert(offsetof(InventoryFSM_OnCharacterHealthModified, DamageCauser) == 0x000020, "Member 'InventoryFSM_OnCharacterHealthModified::DamageCauser' has a wrong offset!");

// Function Phoenix.PhoenixGameModeBase.GetDifficultySettings
// 0x0010 (0x0010 - 0x0000)
struct PhoenixGameModeBase_GetDifficultySettings final
{
public:
	EPhxDifficultyLevel                           InDifficulty;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	const class UPhxDifficultySettings*           ReturnValue;                                       // 0x0008(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixGameModeBase_GetDifficultySettings) == 0x000008, "Wrong alignment on PhoenixGameModeBase_GetDifficultySettings");
static_assert(sizeof(PhoenixGameModeBase_GetDifficultySettings) == 0x000010, "Wrong size on PhoenixGameModeBase_GetDifficultySettings");
static_assert(offsetof(PhoenixGameModeBase_GetDifficultySettings, InDifficulty) == 0x000000, "Member 'PhoenixGameModeBase_GetDifficultySettings::InDifficulty' has a wrong offset!");
static_assert(offsetof(PhoenixGameModeBase_GetDifficultySettings, ReturnValue) == 0x000008, "Member 'PhoenixGameModeBase_GetDifficultySettings::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDifficultySettings.GetAmmoDropQuantityMultiplier
// 0x0004 (0x0004 - 0x0000)
struct PhxDifficultySettings_GetAmmoDropQuantityMultiplier final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDifficultySettings_GetAmmoDropQuantityMultiplier) == 0x000004, "Wrong alignment on PhxDifficultySettings_GetAmmoDropQuantityMultiplier");
static_assert(sizeof(PhxDifficultySettings_GetAmmoDropQuantityMultiplier) == 0x000004, "Wrong size on PhxDifficultySettings_GetAmmoDropQuantityMultiplier");
static_assert(offsetof(PhxDifficultySettings_GetAmmoDropQuantityMultiplier, ReturnValue) == 0x000000, "Member 'PhxDifficultySettings_GetAmmoDropQuantityMultiplier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDifficultySettings.GetCreditsDropQuantityMultiplier
// 0x0004 (0x0004 - 0x0000)
struct PhxDifficultySettings_GetCreditsDropQuantityMultiplier final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDifficultySettings_GetCreditsDropQuantityMultiplier) == 0x000004, "Wrong alignment on PhxDifficultySettings_GetCreditsDropQuantityMultiplier");
static_assert(sizeof(PhxDifficultySettings_GetCreditsDropQuantityMultiplier) == 0x000004, "Wrong size on PhxDifficultySettings_GetCreditsDropQuantityMultiplier");
static_assert(offsetof(PhxDifficultySettings_GetCreditsDropQuantityMultiplier, ReturnValue) == 0x000000, "Member 'PhxDifficultySettings_GetCreditsDropQuantityMultiplier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDifficultySettings.GetCustomAutoSaveToken
// 0x0010 (0x0010 - 0x0000)
struct PhxDifficultySettings_GetCustomAutoSaveToken final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDifficultySettings_GetCustomAutoSaveToken) == 0x000008, "Wrong alignment on PhxDifficultySettings_GetCustomAutoSaveToken");
static_assert(sizeof(PhxDifficultySettings_GetCustomAutoSaveToken) == 0x000010, "Wrong size on PhxDifficultySettings_GetCustomAutoSaveToken");
static_assert(offsetof(PhxDifficultySettings_GetCustomAutoSaveToken, ReturnValue) == 0x000000, "Member 'PhxDifficultySettings_GetCustomAutoSaveToken::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDifficultySettings.GetGRPGrabCostMultiplier
// 0x0004 (0x0004 - 0x0000)
struct PhxDifficultySettings_GetGRPGrabCostMultiplier final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDifficultySettings_GetGRPGrabCostMultiplier) == 0x000004, "Wrong alignment on PhxDifficultySettings_GetGRPGrabCostMultiplier");
static_assert(sizeof(PhxDifficultySettings_GetGRPGrabCostMultiplier) == 0x000004, "Wrong size on PhxDifficultySettings_GetGRPGrabCostMultiplier");
static_assert(offsetof(PhxDifficultySettings_GetGRPGrabCostMultiplier, ReturnValue) == 0x000000, "Member 'PhxDifficultySettings_GetGRPGrabCostMultiplier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDifficultySettings.GetGRPHoldCostMultiplier
// 0x0004 (0x0004 - 0x0000)
struct PhxDifficultySettings_GetGRPHoldCostMultiplier final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDifficultySettings_GetGRPHoldCostMultiplier) == 0x000004, "Wrong alignment on PhxDifficultySettings_GetGRPHoldCostMultiplier");
static_assert(sizeof(PhxDifficultySettings_GetGRPHoldCostMultiplier) == 0x000004, "Wrong size on PhxDifficultySettings_GetGRPHoldCostMultiplier");
static_assert(offsetof(PhxDifficultySettings_GetGRPHoldCostMultiplier, ReturnValue) == 0x000000, "Member 'PhxDifficultySettings_GetGRPHoldCostMultiplier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDifficultySettings.GetHealAmountMultiplier
// 0x0004 (0x0004 - 0x0000)
struct PhxDifficultySettings_GetHealAmountMultiplier final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDifficultySettings_GetHealAmountMultiplier) == 0x000004, "Wrong alignment on PhxDifficultySettings_GetHealAmountMultiplier");
static_assert(sizeof(PhxDifficultySettings_GetHealAmountMultiplier) == 0x000004, "Wrong size on PhxDifficultySettings_GetHealAmountMultiplier");
static_assert(offsetof(PhxDifficultySettings_GetHealAmountMultiplier, ReturnValue) == 0x000000, "Member 'PhxDifficultySettings_GetHealAmountMultiplier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDifficultySettings.GetTimeAfterVirusToMutateMultiplier
// 0x0004 (0x0004 - 0x0000)
struct PhxDifficultySettings_GetTimeAfterVirusToMutateMultiplier final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDifficultySettings_GetTimeAfterVirusToMutateMultiplier) == 0x000004, "Wrong alignment on PhxDifficultySettings_GetTimeAfterVirusToMutateMultiplier");
static_assert(sizeof(PhxDifficultySettings_GetTimeAfterVirusToMutateMultiplier) == 0x000004, "Wrong size on PhxDifficultySettings_GetTimeAfterVirusToMutateMultiplier");
static_assert(offsetof(PhxDifficultySettings_GetTimeAfterVirusToMutateMultiplier, ReturnValue) == 0x000000, "Member 'PhxDifficultySettings_GetTimeAfterVirusToMutateMultiplier::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryTab.SetSelected
// 0x0001 (0x0001 - 0x0000)
struct InventoryTab_SetSelected final
{
public:
	bool                                          bSelected;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryTab_SetSelected) == 0x000001, "Wrong alignment on InventoryTab_SetSelected");
static_assert(sizeof(InventoryTab_SetSelected) == 0x000001, "Wrong size on InventoryTab_SetSelected");
static_assert(offsetof(InventoryTab_SetSelected, bSelected) == 0x000000, "Member 'InventoryTab_SetSelected::bSelected' has a wrong offset!");

// Function Phoenix.PhxAISenseComponent.EnableSensing
// 0x0001 (0x0001 - 0x0000)
struct PhxAISenseComponent_EnableSensing final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISenseComponent_EnableSensing) == 0x000001, "Wrong alignment on PhxAISenseComponent_EnableSensing");
static_assert(sizeof(PhxAISenseComponent_EnableSensing) == 0x000001, "Wrong size on PhxAISenseComponent_EnableSensing");
static_assert(offsetof(PhxAISenseComponent_EnableSensing, bEnabled) == 0x000000, "Member 'PhxAISenseComponent_EnableSensing::bEnabled' has a wrong offset!");

// Function Phoenix.PhxAISenseComponent.HandleSourceDestroyed
// 0x0008 (0x0008 - 0x0000)
struct PhxAISenseComponent_HandleSourceDestroyed final
{
public:
	class AActor*                                 DestroyedActor;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISenseComponent_HandleSourceDestroyed) == 0x000008, "Wrong alignment on PhxAISenseComponent_HandleSourceDestroyed");
static_assert(sizeof(PhxAISenseComponent_HandleSourceDestroyed) == 0x000008, "Wrong size on PhxAISenseComponent_HandleSourceDestroyed");
static_assert(offsetof(PhxAISenseComponent_HandleSourceDestroyed, DestroyedActor) == 0x000000, "Member 'PhxAISenseComponent_HandleSourceDestroyed::DestroyedActor' has a wrong offset!");

// Function Phoenix.InventoryOverlayWidget.GetEquipmentWidget
// 0x0008 (0x0008 - 0x0000)
struct InventoryOverlayWidget_GetEquipmentWidget final
{
public:
	class UInventoryEquipmentGridWidget*          ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryOverlayWidget_GetEquipmentWidget) == 0x000008, "Wrong alignment on InventoryOverlayWidget_GetEquipmentWidget");
static_assert(sizeof(InventoryOverlayWidget_GetEquipmentWidget) == 0x000008, "Wrong size on InventoryOverlayWidget_GetEquipmentWidget");
static_assert(offsetof(InventoryOverlayWidget_GetEquipmentWidget, ReturnValue) == 0x000000, "Member 'InventoryOverlayWidget_GetEquipmentWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryOverlayWidget.GetSalvageWidget
// 0x0008 (0x0008 - 0x0000)
struct InventoryOverlayWidget_GetSalvageWidget final
{
public:
	class UInventoryItemGridWidget*               ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryOverlayWidget_GetSalvageWidget) == 0x000008, "Wrong alignment on InventoryOverlayWidget_GetSalvageWidget");
static_assert(sizeof(InventoryOverlayWidget_GetSalvageWidget) == 0x000008, "Wrong size on InventoryOverlayWidget_GetSalvageWidget");
static_assert(offsetof(InventoryOverlayWidget_GetSalvageWidget, ReturnValue) == 0x000000, "Member 'InventoryOverlayWidget_GetSalvageWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.Item.GetMeshComp
// 0x0008 (0x0008 - 0x0000)
struct Item_GetMeshComp final
{
public:
	class UStaticMeshComponent*                   ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Item_GetMeshComp) == 0x000008, "Wrong alignment on Item_GetMeshComp");
static_assert(sizeof(Item_GetMeshComp) == 0x000008, "Wrong size on Item_GetMeshComp");
static_assert(offsetof(Item_GetMeshComp, ReturnValue) == 0x000000, "Member 'Item_GetMeshComp::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_Interaction.OnNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayAbility_Interaction_OnNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_Interaction_OnNotifyReceived) == 0x000008, "Wrong alignment on PhxGameplayAbility_Interaction_OnNotifyReceived");
static_assert(sizeof(PhxGameplayAbility_Interaction_OnNotifyReceived) == 0x000008, "Wrong size on PhxGameplayAbility_Interaction_OnNotifyReceived");
static_assert(offsetof(PhxGameplayAbility_Interaction_OnNotifyReceived, Notify) == 0x000000, "Member 'PhxGameplayAbility_Interaction_OnNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_Interaction.OnNotifyStateBegin
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayAbility_Interaction_OnNotifyStateBegin final
{
public:
	const class UPhxAnimNotifyState*              NotifyState;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequenceBase*                      Animation;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_Interaction_OnNotifyStateBegin) == 0x000008, "Wrong alignment on PhxGameplayAbility_Interaction_OnNotifyStateBegin");
static_assert(sizeof(PhxGameplayAbility_Interaction_OnNotifyStateBegin) == 0x000010, "Wrong size on PhxGameplayAbility_Interaction_OnNotifyStateBegin");
static_assert(offsetof(PhxGameplayAbility_Interaction_OnNotifyStateBegin, NotifyState) == 0x000000, "Member 'PhxGameplayAbility_Interaction_OnNotifyStateBegin::NotifyState' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_Interaction_OnNotifyStateBegin, Animation) == 0x000008, "Member 'PhxGameplayAbility_Interaction_OnNotifyStateBegin::Animation' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_Interaction.OnNotifyStateEnd
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayAbility_Interaction_OnNotifyStateEnd final
{
public:
	const class UPhxAnimNotifyState*              NotifyState;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequenceBase*                      Animation;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_Interaction_OnNotifyStateEnd) == 0x000008, "Wrong alignment on PhxGameplayAbility_Interaction_OnNotifyStateEnd");
static_assert(sizeof(PhxGameplayAbility_Interaction_OnNotifyStateEnd) == 0x000010, "Wrong size on PhxGameplayAbility_Interaction_OnNotifyStateEnd");
static_assert(offsetof(PhxGameplayAbility_Interaction_OnNotifyStateEnd, NotifyState) == 0x000000, "Member 'PhxGameplayAbility_Interaction_OnNotifyStateEnd::NotifyState' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_Interaction_OnNotifyStateEnd, Animation) == 0x000008, "Member 'PhxGameplayAbility_Interaction_OnNotifyStateEnd::Animation' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_GadgetInteraction.OnCharacterHealthModified
// 0x0028 (0x0028 - 0x0000)
struct PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified final
{
public:
	class UPhxHealthComponent*                    HealthComp;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HealthDelta;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified) == 0x000008, "Wrong alignment on PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified");
static_assert(sizeof(PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified) == 0x000028, "Wrong size on PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified");
static_assert(offsetof(PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified, HealthComp) == 0x000000, "Member 'PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified::HealthComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified, Health) == 0x000008, "Member 'PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified::Health' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified, HealthDelta) == 0x00000C, "Member 'PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified::HealthDelta' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified, DamageType) == 0x000010, "Member 'PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified::DamageType' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified, InstigatedBy) == 0x000018, "Member 'PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified, DamageCauser) == 0x000020, "Member 'PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_GadgetInteraction.OnInteractableComponentEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayAbility_GadgetInteraction_OnInteractableComponentEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_GadgetInteraction_OnInteractableComponentEnabled) == 0x000001, "Wrong alignment on PhxGameplayAbility_GadgetInteraction_OnInteractableComponentEnabled");
static_assert(sizeof(PhxGameplayAbility_GadgetInteraction_OnInteractableComponentEnabled) == 0x000001, "Wrong size on PhxGameplayAbility_GadgetInteraction_OnInteractableComponentEnabled");
static_assert(offsetof(PhxGameplayAbility_GadgetInteraction_OnInteractableComponentEnabled, bEnabled) == 0x000000, "Member 'PhxGameplayAbility_GadgetInteraction_OnInteractableComponentEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.DevMenuState.OnPlayerInventoryChanged
// 0x000C (0x000C - 0x0000)
struct DevMenuState_OnPlayerInventoryChanged final
{
public:
	class FName                                   Name_0;                                            // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Quantity;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(DevMenuState_OnPlayerInventoryChanged) == 0x000004, "Wrong alignment on DevMenuState_OnPlayerInventoryChanged");
static_assert(sizeof(DevMenuState_OnPlayerInventoryChanged) == 0x00000C, "Wrong size on DevMenuState_OnPlayerInventoryChanged");
static_assert(offsetof(DevMenuState_OnPlayerInventoryChanged, Name_0) == 0x000000, "Member 'DevMenuState_OnPlayerInventoryChanged::Name_0' has a wrong offset!");
static_assert(offsetof(DevMenuState_OnPlayerInventoryChanged, Quantity) == 0x000008, "Member 'DevMenuState_OnPlayerInventoryChanged::Quantity' has a wrong offset!");

// Function Phoenix.DoorUIWidget.UpdateLocked
// 0x0001 (0x0001 - 0x0000)
struct DoorUIWidget_UpdateLocked final
{
public:
	bool                                          bLocked;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(DoorUIWidget_UpdateLocked) == 0x000001, "Wrong alignment on DoorUIWidget_UpdateLocked");
static_assert(sizeof(DoorUIWidget_UpdateLocked) == 0x000001, "Wrong size on DoorUIWidget_UpdateLocked");
static_assert(offsetof(DoorUIWidget_UpdateLocked, bLocked) == 0x000000, "Member 'DoorUIWidget_UpdateLocked::bLocked' has a wrong offset!");

// Function Phoenix.DoorUIWidget.UpdatePhxControllerType
// 0x0001 (0x0001 - 0x0000)
struct DoorUIWidget_UpdatePhxControllerType final
{
public:
	EPhxControllerType                            ControllerType;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(DoorUIWidget_UpdatePhxControllerType) == 0x000001, "Wrong alignment on DoorUIWidget_UpdatePhxControllerType");
static_assert(sizeof(DoorUIWidget_UpdatePhxControllerType) == 0x000001, "Wrong size on DoorUIWidget_UpdatePhxControllerType");
static_assert(offsetof(DoorUIWidget_UpdatePhxControllerType, ControllerType) == 0x000000, "Member 'DoorUIWidget_UpdatePhxControllerType::ControllerType' has a wrong offset!");

// Function Phoenix.PhxAISpawner_Character.DespawnAI
// 0x0001 (0x0001 - 0x0000)
struct PhxAISpawner_Character_DespawnAI final
{
public:
	EPhxAIDespawnReason                           Reason;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawner_Character_DespawnAI) == 0x000001, "Wrong alignment on PhxAISpawner_Character_DespawnAI");
static_assert(sizeof(PhxAISpawner_Character_DespawnAI) == 0x000001, "Wrong size on PhxAISpawner_Character_DespawnAI");
static_assert(offsetof(PhxAISpawner_Character_DespawnAI, Reason) == 0x000000, "Member 'PhxAISpawner_Character_DespawnAI::Reason' has a wrong offset!");

// Function Phoenix.PhxAISpawner_Character.HandleAISpawned
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawner_Character_HandleAISpawned final
{
public:
	class APhxAICharacter*                        SpawnedAI;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAISpawnResultCode                         ResultCode;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SpawnUid;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawner_Character_HandleAISpawned) == 0x000008, "Wrong alignment on PhxAISpawner_Character_HandleAISpawned");
static_assert(sizeof(PhxAISpawner_Character_HandleAISpawned) == 0x000010, "Wrong size on PhxAISpawner_Character_HandleAISpawned");
static_assert(offsetof(PhxAISpawner_Character_HandleAISpawned, SpawnedAI) == 0x000000, "Member 'PhxAISpawner_Character_HandleAISpawned::SpawnedAI' has a wrong offset!");
static_assert(offsetof(PhxAISpawner_Character_HandleAISpawned, ResultCode) == 0x000008, "Member 'PhxAISpawner_Character_HandleAISpawned::ResultCode' has a wrong offset!");
static_assert(offsetof(PhxAISpawner_Character_HandleAISpawned, SpawnUid) == 0x00000C, "Member 'PhxAISpawner_Character_HandleAISpawned::SpawnUid' has a wrong offset!");

// Function Phoenix.PhxAISpawner_Character.SetCharacterDefinition
// 0x0030 (0x0030 - 0x0000)
struct PhxAISpawner_Character_SetCharacterDefinition final
{
public:
	TSoftObjectPtr<class UPhxAICharacterDefinition> InAICharacterDefinitionPtr;                      // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InCharacterVariation;                              // 0x0028(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAISpawner_Character_SetCharacterDefinition) == 0x000008, "Wrong alignment on PhxAISpawner_Character_SetCharacterDefinition");
static_assert(sizeof(PhxAISpawner_Character_SetCharacterDefinition) == 0x000030, "Wrong size on PhxAISpawner_Character_SetCharacterDefinition");
static_assert(offsetof(PhxAISpawner_Character_SetCharacterDefinition, InAICharacterDefinitionPtr) == 0x000000, "Member 'PhxAISpawner_Character_SetCharacterDefinition::InAICharacterDefinitionPtr' has a wrong offset!");
static_assert(offsetof(PhxAISpawner_Character_SetCharacterDefinition, InCharacterVariation) == 0x000028, "Member 'PhxAISpawner_Character_SetCharacterDefinition::InCharacterVariation' has a wrong offset!");

// Function Phoenix.PhxAISpawner_Character.GetLastSpawnedAI
// 0x0008 (0x0008 - 0x0000)
struct PhxAISpawner_Character_GetLastSpawnedAI final
{
public:
	class APhxAICharacter*                        ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawner_Character_GetLastSpawnedAI) == 0x000008, "Wrong alignment on PhxAISpawner_Character_GetLastSpawnedAI");
static_assert(sizeof(PhxAISpawner_Character_GetLastSpawnedAI) == 0x000008, "Wrong size on PhxAISpawner_Character_GetLastSpawnedAI");
static_assert(offsetof(PhxAISpawner_Character_GetLastSpawnedAI, ReturnValue) == 0x000000, "Member 'PhxAISpawner_Character_GetLastSpawnedAI::ReturnValue' has a wrong offset!");

// Function Phoenix.KraftonIdCountdownTimer.UpdatePercent
// 0x0004 (0x0004 - 0x0000)
struct KraftonIdCountdownTimer_UpdatePercent final
{
public:
	float                                         Percent;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(KraftonIdCountdownTimer_UpdatePercent) == 0x000004, "Wrong alignment on KraftonIdCountdownTimer_UpdatePercent");
static_assert(sizeof(KraftonIdCountdownTimer_UpdatePercent) == 0x000004, "Wrong size on KraftonIdCountdownTimer_UpdatePercent");
static_assert(offsetof(KraftonIdCountdownTimer_UpdatePercent, Percent) == 0x000000, "Member 'KraftonIdCountdownTimer_UpdatePercent::Percent' has a wrong offset!");

// Function Phoenix.PhxAIShoutBeaconActor.SpawnShoutBeacon
// 0x0030 (0x0030 - 0x0000)
struct PhxAIShoutBeaconActor_SpawnShoutBeacon final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APawn*                                  ShoutInstigator;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                BeaconLocation;                                    // 0x0010(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UCurveFloat*                            BeaconRadiusCurve;                                 // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNiagaraSystem*                         OnBeginParticleFX_0;                               // 0x0028(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIShoutBeaconActor_SpawnShoutBeacon) == 0x000008, "Wrong alignment on PhxAIShoutBeaconActor_SpawnShoutBeacon");
static_assert(sizeof(PhxAIShoutBeaconActor_SpawnShoutBeacon) == 0x000030, "Wrong size on PhxAIShoutBeaconActor_SpawnShoutBeacon");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeacon, WorldContextObject) == 0x000000, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeacon::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeacon, ShoutInstigator) == 0x000008, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeacon::ShoutInstigator' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeacon, BeaconLocation) == 0x000010, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeacon::BeaconLocation' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeacon, BeaconRadiusCurve) == 0x000020, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeacon::BeaconRadiusCurve' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeacon, OnBeginParticleFX_0) == 0x000028, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeacon::OnBeginParticleFX_0' has a wrong offset!");

// Function Phoenix.PhxAIShoutBeaconActor.SpawnShoutBeaconAttachedToActor
// 0x0040 (0x0040 - 0x0000)
struct PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APawn*                                  ShoutInstigator;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 BeaconAnchor;                                      // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UCurveFloat*                            BeaconRadiusCurve;                                 // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNiagaraSystem*                         OnBeginParticleFX_0;                               // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InDetachmentTime;                                  // 0x0028(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UNiagaraSystem*                         AttachedParticleFX;                                // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   AttachmentLocationName;                            // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor) == 0x000008, "Wrong alignment on PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor");
static_assert(sizeof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor) == 0x000040, "Wrong size on PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor, WorldContextObject) == 0x000000, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor, ShoutInstigator) == 0x000008, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor::ShoutInstigator' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor, BeaconAnchor) == 0x000010, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor::BeaconAnchor' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor, BeaconRadiusCurve) == 0x000018, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor::BeaconRadiusCurve' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor, OnBeginParticleFX_0) == 0x000020, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor::OnBeginParticleFX_0' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor, InDetachmentTime) == 0x000028, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor::InDetachmentTime' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor, AttachedParticleFX) == 0x000030, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor::AttachedParticleFX' has a wrong offset!");
static_assert(offsetof(PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor, AttachmentLocationName) == 0x000038, "Member 'PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor::AttachmentLocationName' has a wrong offset!");

// Function Phoenix.InventoryItemsPanel.CanStartConsuming
// 0x0010 (0x0010 - 0x0000)
struct InventoryItemsPanel_CanStartConsuming final
{
public:
	const class UInventorySlot*                   InSlot;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryItemsPanel_CanStartConsuming) == 0x000008, "Wrong alignment on InventoryItemsPanel_CanStartConsuming");
static_assert(sizeof(InventoryItemsPanel_CanStartConsuming) == 0x000010, "Wrong size on InventoryItemsPanel_CanStartConsuming");
static_assert(offsetof(InventoryItemsPanel_CanStartConsuming, InSlot) == 0x000000, "Member 'InventoryItemsPanel_CanStartConsuming::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryItemsPanel_CanStartConsuming, ReturnValue) == 0x000008, "Member 'InventoryItemsPanel_CanStartConsuming::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryItemsPanel.IsConsumableSlot
// 0x0010 (0x0010 - 0x0000)
struct InventoryItemsPanel_IsConsumableSlot final
{
public:
	const class UInventorySlot*                   InSlot;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryItemsPanel_IsConsumableSlot) == 0x000008, "Wrong alignment on InventoryItemsPanel_IsConsumableSlot");
static_assert(sizeof(InventoryItemsPanel_IsConsumableSlot) == 0x000010, "Wrong size on InventoryItemsPanel_IsConsumableSlot");
static_assert(offsetof(InventoryItemsPanel_IsConsumableSlot, InSlot) == 0x000000, "Member 'InventoryItemsPanel_IsConsumableSlot::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryItemsPanel_IsConsumableSlot, ReturnValue) == 0x000008, "Member 'InventoryItemsPanel_IsConsumableSlot::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryItemsPanel.IsHealthSlot
// 0x0010 (0x0010 - 0x0000)
struct InventoryItemsPanel_IsHealthSlot final
{
public:
	const class UInventorySlot*                   InSlot;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryItemsPanel_IsHealthSlot) == 0x000008, "Wrong alignment on InventoryItemsPanel_IsHealthSlot");
static_assert(sizeof(InventoryItemsPanel_IsHealthSlot) == 0x000010, "Wrong size on InventoryItemsPanel_IsHealthSlot");
static_assert(offsetof(InventoryItemsPanel_IsHealthSlot, InSlot) == 0x000000, "Member 'InventoryItemsPanel_IsHealthSlot::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryItemsPanel_IsHealthSlot, ReturnValue) == 0x000008, "Member 'InventoryItemsPanel_IsHealthSlot::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHasEntitlement.HasEntitlement
// 0x0010 (0x0010 - 0x0000)
struct PhxHasEntitlement_HasEntitlement final
{
public:
	EPhxEntitlement                               InEntitlement;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxHasEntitlement*                     ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasEntitlement_HasEntitlement) == 0x000008, "Wrong alignment on PhxHasEntitlement_HasEntitlement");
static_assert(sizeof(PhxHasEntitlement_HasEntitlement) == 0x000010, "Wrong size on PhxHasEntitlement_HasEntitlement");
static_assert(offsetof(PhxHasEntitlement_HasEntitlement, InEntitlement) == 0x000000, "Member 'PhxHasEntitlement_HasEntitlement::InEntitlement' has a wrong offset!");
static_assert(offsetof(PhxHasEntitlement_HasEntitlement, ReturnValue) == 0x000008, "Member 'PhxHasEntitlement_HasEntitlement::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHasEntitlement.HandleFetchEntitlements
// 0x0050 (0x0050 - 0x0000)
struct PhxHasEntitlement_HandleFetchEntitlements final
{
public:
	struct FPhxEntitlementOwnership               Ownership;                                         // 0x0000(0x0050)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasEntitlement_HandleFetchEntitlements) == 0x000008, "Wrong alignment on PhxHasEntitlement_HandleFetchEntitlements");
static_assert(sizeof(PhxHasEntitlement_HandleFetchEntitlements) == 0x000050, "Wrong size on PhxHasEntitlement_HandleFetchEntitlements");
static_assert(offsetof(PhxHasEntitlement_HandleFetchEntitlements, Ownership) == 0x000000, "Member 'PhxHasEntitlement_HandleFetchEntitlements::Ownership' has a wrong offset!");

// Function Phoenix.PhxHasEntitlement.HandleFetchOnlineAccount
// 0x0010 (0x0010 - 0x0000)
struct PhxHasEntitlement_HandleFetchOnlineAccount final
{
public:
	bool                                          bSuccess;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	const class USDSOnlineAccount*                OnlineAccount;                                     // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasEntitlement_HandleFetchOnlineAccount) == 0x000008, "Wrong alignment on PhxHasEntitlement_HandleFetchOnlineAccount");
static_assert(sizeof(PhxHasEntitlement_HandleFetchOnlineAccount) == 0x000010, "Wrong size on PhxHasEntitlement_HandleFetchOnlineAccount");
static_assert(offsetof(PhxHasEntitlement_HandleFetchOnlineAccount, bSuccess) == 0x000000, "Member 'PhxHasEntitlement_HandleFetchOnlineAccount::bSuccess' has a wrong offset!");
static_assert(offsetof(PhxHasEntitlement_HandleFetchOnlineAccount, OnlineAccount) == 0x000008, "Member 'PhxHasEntitlement_HandleFetchOnlineAccount::OnlineAccount' has a wrong offset!");

// Function Phoenix.EchoComponent.SetCaptureOffset
// 0x000C (0x000C - 0x0000)
struct EchoComponent_SetCaptureOffset final
{
public:
	struct FVector                                Offset;                                            // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoComponent_SetCaptureOffset) == 0x000004, "Wrong alignment on EchoComponent_SetCaptureOffset");
static_assert(sizeof(EchoComponent_SetCaptureOffset) == 0x00000C, "Wrong size on EchoComponent_SetCaptureOffset");
static_assert(offsetof(EchoComponent_SetCaptureOffset, Offset) == 0x000000, "Member 'EchoComponent_SetCaptureOffset::Offset' has a wrong offset!");

// Function Phoenix.EchoComponent.UpdateEchoParameters
// 0x0010 (0x0010 - 0x0000)
struct EchoComponent_UpdateEchoParameters final
{
public:
	class USceneCaptureComponent2D*               SceneCaptureComponent;                             // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNiagaraComponent*                      EchoParticles;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoComponent_UpdateEchoParameters) == 0x000008, "Wrong alignment on EchoComponent_UpdateEchoParameters");
static_assert(sizeof(EchoComponent_UpdateEchoParameters) == 0x000010, "Wrong size on EchoComponent_UpdateEchoParameters");
static_assert(offsetof(EchoComponent_UpdateEchoParameters, SceneCaptureComponent) == 0x000000, "Member 'EchoComponent_UpdateEchoParameters::SceneCaptureComponent' has a wrong offset!");
static_assert(offsetof(EchoComponent_UpdateEchoParameters, EchoParticles) == 0x000008, "Member 'EchoComponent_UpdateEchoParameters::EchoParticles' has a wrong offset!");

// Function Phoenix.InteractableProxy.OnInteractionExecuted
// 0x0008 (0x0008 - 0x0000)
struct InteractableProxy_OnInteractionExecuted final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractableProxy_OnInteractionExecuted) == 0x000008, "Wrong alignment on InteractableProxy_OnInteractionExecuted");
static_assert(sizeof(InteractableProxy_OnInteractionExecuted) == 0x000008, "Wrong size on InteractableProxy_OnInteractionExecuted");
static_assert(offsetof(InteractableProxy_OnInteractionExecuted, InteractedBy) == 0x000000, "Member 'InteractableProxy_OnInteractionExecuted::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.OnCharacterInteractExecuted
// 0x0008 (0x0008 - 0x0000)
struct PhxScriptedEventActor_OnCharacterInteractExecuted final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_OnCharacterInteractExecuted) == 0x000008, "Wrong alignment on PhxScriptedEventActor_OnCharacterInteractExecuted");
static_assert(sizeof(PhxScriptedEventActor_OnCharacterInteractExecuted) == 0x000008, "Wrong size on PhxScriptedEventActor_OnCharacterInteractExecuted");
static_assert(offsetof(PhxScriptedEventActor_OnCharacterInteractExecuted, Character) == 0x000000, "Member 'PhxScriptedEventActor_OnCharacterInteractExecuted::Character' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.RequestCharacterSwapsForNextCinematic
// 0x0050 (0x0050 - 0x0000)
struct PhxScriptedEventActor_RequestCharacterSwapsForNextCinematic final
{
public:
	TMap<class FName, TSoftClassPtr<class UClass>> BindingTagsAndRequestedClasses;                   // 0x0000(0x0050)(Parm, UObjectWrapper, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_RequestCharacterSwapsForNextCinematic) == 0x000008, "Wrong alignment on PhxScriptedEventActor_RequestCharacterSwapsForNextCinematic");
static_assert(sizeof(PhxScriptedEventActor_RequestCharacterSwapsForNextCinematic) == 0x000050, "Wrong size on PhxScriptedEventActor_RequestCharacterSwapsForNextCinematic");
static_assert(offsetof(PhxScriptedEventActor_RequestCharacterSwapsForNextCinematic, BindingTagsAndRequestedClasses) == 0x000000, "Member 'PhxScriptedEventActor_RequestCharacterSwapsForNextCinematic::BindingTagsAndRequestedClasses' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.SetAttachInfoOnQTEUsingActorComp
// 0x0168 (0x0168 - 0x0000)
struct PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp final
{
public:
	struct FQteRequest                            InQteRequest;                                      // 0x0000(0x0150)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class FName                                   AttachActorBindingTag;                             // 0x0150(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   AttachComponentName;                               // 0x0158(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   AttachSocketName;                                  // 0x0160(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp) == 0x000008, "Wrong alignment on PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp");
static_assert(sizeof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp) == 0x000168, "Wrong size on PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp");
static_assert(offsetof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp, InQteRequest) == 0x000000, "Member 'PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp::InQteRequest' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp, AttachActorBindingTag) == 0x000150, "Member 'PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp::AttachActorBindingTag' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp, AttachComponentName) == 0x000158, "Member 'PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp::AttachComponentName' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp, AttachSocketName) == 0x000160, "Member 'PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp::AttachSocketName' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.SetAttachInfoOnQTEUsingActorSkeletalMesh
// 0x0160 (0x0160 - 0x0000)
struct PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh final
{
public:
	struct FQteRequest                            InQteRequest;                                      // 0x0000(0x0150)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class FName                                   AttachActorBindingTag;                             // 0x0150(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   AttachBoneName;                                    // 0x0158(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh) == 0x000008, "Wrong alignment on PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh");
static_assert(sizeof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh) == 0x000160, "Wrong size on PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh");
static_assert(offsetof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh, InQteRequest) == 0x000000, "Member 'PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh::InQteRequest' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh, AttachActorBindingTag) == 0x000150, "Member 'PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh::AttachActorBindingTag' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh, AttachBoneName) == 0x000158, "Member 'PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh::AttachBoneName' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.StartCameraLookAroundOverrideInterval
// 0x0010 (0x0010 - 0x0000)
struct PhxScriptedEventActor_StartCameraLookAroundOverrideInterval final
{
public:
	int32                                         EndFrame;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxPitchOverride;                                  // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxYawOverride;                                    // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LookSpeedOverride;                                 // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_StartCameraLookAroundOverrideInterval) == 0x000004, "Wrong alignment on PhxScriptedEventActor_StartCameraLookAroundOverrideInterval");
static_assert(sizeof(PhxScriptedEventActor_StartCameraLookAroundOverrideInterval) == 0x000010, "Wrong size on PhxScriptedEventActor_StartCameraLookAroundOverrideInterval");
static_assert(offsetof(PhxScriptedEventActor_StartCameraLookAroundOverrideInterval, EndFrame) == 0x000000, "Member 'PhxScriptedEventActor_StartCameraLookAroundOverrideInterval::EndFrame' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartCameraLookAroundOverrideInterval, MaxPitchOverride) == 0x000004, "Member 'PhxScriptedEventActor_StartCameraLookAroundOverrideInterval::MaxPitchOverride' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartCameraLookAroundOverrideInterval, MaxYawOverride) == 0x000008, "Member 'PhxScriptedEventActor_StartCameraLookAroundOverrideInterval::MaxYawOverride' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartCameraLookAroundOverrideInterval, LookSpeedOverride) == 0x00000C, "Member 'PhxScriptedEventActor_StartCameraLookAroundOverrideInterval::LookSpeedOverride' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.StartPlayerMovementFailureInterval
// 0x0018 (0x0018 - 0x0000)
struct PhxScriptedEventActor_StartPlayerMovementFailureInterval final
{
public:
	int32                                         BranchFrame;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MovementInputFrameDuration;                        // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCheckMoveForward;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCheckMoveBackward;                                // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCheckMoveLeft;                                    // 0x000A(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCheckMoveRight;                                   // 0x000B(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MovementInputThreshold;                            // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   FailureId;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_StartPlayerMovementFailureInterval) == 0x000004, "Wrong alignment on PhxScriptedEventActor_StartPlayerMovementFailureInterval");
static_assert(sizeof(PhxScriptedEventActor_StartPlayerMovementFailureInterval) == 0x000018, "Wrong size on PhxScriptedEventActor_StartPlayerMovementFailureInterval");
static_assert(offsetof(PhxScriptedEventActor_StartPlayerMovementFailureInterval, BranchFrame) == 0x000000, "Member 'PhxScriptedEventActor_StartPlayerMovementFailureInterval::BranchFrame' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartPlayerMovementFailureInterval, MovementInputFrameDuration) == 0x000004, "Member 'PhxScriptedEventActor_StartPlayerMovementFailureInterval::MovementInputFrameDuration' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartPlayerMovementFailureInterval, bCheckMoveForward) == 0x000008, "Member 'PhxScriptedEventActor_StartPlayerMovementFailureInterval::bCheckMoveForward' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartPlayerMovementFailureInterval, bCheckMoveBackward) == 0x000009, "Member 'PhxScriptedEventActor_StartPlayerMovementFailureInterval::bCheckMoveBackward' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartPlayerMovementFailureInterval, bCheckMoveLeft) == 0x00000A, "Member 'PhxScriptedEventActor_StartPlayerMovementFailureInterval::bCheckMoveLeft' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartPlayerMovementFailureInterval, bCheckMoveRight) == 0x00000B, "Member 'PhxScriptedEventActor_StartPlayerMovementFailureInterval::bCheckMoveRight' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartPlayerMovementFailureInterval, MovementInputThreshold) == 0x00000C, "Member 'PhxScriptedEventActor_StartPlayerMovementFailureInterval::MovementInputThreshold' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartPlayerMovementFailureInterval, FailureId) == 0x000010, "Member 'PhxScriptedEventActor_StartPlayerMovementFailureInterval::FailureId' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.StartQteFailureInterval
// 0x0170 (0x0170 - 0x0000)
struct PhxScriptedEventActor_StartQteFailureInterval final
{
public:
	int32                                         BranchFrame;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         QteFrameDuration;                                  // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FQteRequest                            InQteRequest;                                      // 0x0008(0x0150)(Parm, NativeAccessSpecifierPublic)
	class FName                                   FailureId;                                         // 0x0158(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxCinematicPlaybackActions                  FailureAction;                                     // 0x0160(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_161[0x3];                                      // 0x0161(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   SuccessId;                                         // 0x0164(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxCinematicPlaybackActions                  SuccessAction;                                     // 0x016C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFailScriptedEventOnFailure;                       // 0x016D(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_16E[0x2];                                      // 0x016E(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxScriptedEventActor_StartQteFailureInterval) == 0x000008, "Wrong alignment on PhxScriptedEventActor_StartQteFailureInterval");
static_assert(sizeof(PhxScriptedEventActor_StartQteFailureInterval) == 0x000170, "Wrong size on PhxScriptedEventActor_StartQteFailureInterval");
static_assert(offsetof(PhxScriptedEventActor_StartQteFailureInterval, BranchFrame) == 0x000000, "Member 'PhxScriptedEventActor_StartQteFailureInterval::BranchFrame' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartQteFailureInterval, QteFrameDuration) == 0x000004, "Member 'PhxScriptedEventActor_StartQteFailureInterval::QteFrameDuration' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartQteFailureInterval, InQteRequest) == 0x000008, "Member 'PhxScriptedEventActor_StartQteFailureInterval::InQteRequest' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartQteFailureInterval, FailureId) == 0x000158, "Member 'PhxScriptedEventActor_StartQteFailureInterval::FailureId' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartQteFailureInterval, FailureAction) == 0x000160, "Member 'PhxScriptedEventActor_StartQteFailureInterval::FailureAction' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartQteFailureInterval, SuccessId) == 0x000164, "Member 'PhxScriptedEventActor_StartQteFailureInterval::SuccessId' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartQteFailureInterval, SuccessAction) == 0x00016C, "Member 'PhxScriptedEventActor_StartQteFailureInterval::SuccessAction' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StartQteFailureInterval, bFailScriptedEventOnFailure) == 0x00016D, "Member 'PhxScriptedEventActor_StartQteFailureInterval::bFailScriptedEventOnFailure' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.StopLoopingCinematic
// 0x000C (0x000C - 0x0000)
struct PhxScriptedEventActor_StopLoopingCinematic final
{
public:
	bool                                          bWaitForCinematicToEnd;                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   NextCinematicRowOverrideName;                      // 0x0004(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_StopLoopingCinematic) == 0x000004, "Wrong alignment on PhxScriptedEventActor_StopLoopingCinematic");
static_assert(sizeof(PhxScriptedEventActor_StopLoopingCinematic) == 0x00000C, "Wrong size on PhxScriptedEventActor_StopLoopingCinematic");
static_assert(offsetof(PhxScriptedEventActor_StopLoopingCinematic, bWaitForCinematicToEnd) == 0x000000, "Member 'PhxScriptedEventActor_StopLoopingCinematic::bWaitForCinematicToEnd' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_StopLoopingCinematic, NextCinematicRowOverrideName) == 0x000004, "Member 'PhxScriptedEventActor_StopLoopingCinematic::NextCinematicRowOverrideName' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.StopScriptedEvent
// 0x0001 (0x0001 - 0x0000)
struct PhxScriptedEventActor_StopScriptedEvent final
{
public:
	bool                                          bStopImmediately;                                  // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_StopScriptedEvent) == 0x000001, "Wrong alignment on PhxScriptedEventActor_StopScriptedEvent");
static_assert(sizeof(PhxScriptedEventActor_StopScriptedEvent) == 0x000001, "Wrong size on PhxScriptedEventActor_StopScriptedEvent");
static_assert(offsetof(PhxScriptedEventActor_StopScriptedEvent, bStopImmediately) == 0x000000, "Member 'PhxScriptedEventActor_StopScriptedEvent::bStopImmediately' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.GetActorBoundToTag
// 0x0030 (0x0030 - 0x0000)
struct PhxScriptedEventActor_GetActorBoundToTag final
{
public:
	class FName                                   BindingTag;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class AActor>                  ReturnValue;                                       // 0x0008(0x0028)(Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_GetActorBoundToTag) == 0x000008, "Wrong alignment on PhxScriptedEventActor_GetActorBoundToTag");
static_assert(sizeof(PhxScriptedEventActor_GetActorBoundToTag) == 0x000030, "Wrong size on PhxScriptedEventActor_GetActorBoundToTag");
static_assert(offsetof(PhxScriptedEventActor_GetActorBoundToTag, BindingTag) == 0x000000, "Member 'PhxScriptedEventActor_GetActorBoundToTag::BindingTag' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_GetActorBoundToTag, ReturnValue) == 0x000008, "Member 'PhxScriptedEventActor_GetActorBoundToTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.GetCinematicsComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxScriptedEventActor_GetCinematicsComponent final
{
public:
	class UPhxCinematicsComponent*                ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_GetCinematicsComponent) == 0x000008, "Wrong alignment on PhxScriptedEventActor_GetCinematicsComponent");
static_assert(sizeof(PhxScriptedEventActor_GetCinematicsComponent) == 0x000008, "Wrong size on PhxScriptedEventActor_GetCinematicsComponent");
static_assert(offsetof(PhxScriptedEventActor_GetCinematicsComponent, ReturnValue) == 0x000000, "Member 'PhxScriptedEventActor_GetCinematicsComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.GetListOfLevelSequences
// 0x0010 (0x0010 - 0x0000)
struct PhxScriptedEventActor_GetListOfLevelSequences final
{
public:
	TArray<struct FSoftObjectPath>                ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_GetListOfLevelSequences) == 0x000008, "Wrong alignment on PhxScriptedEventActor_GetListOfLevelSequences");
static_assert(sizeof(PhxScriptedEventActor_GetListOfLevelSequences) == 0x000010, "Wrong size on PhxScriptedEventActor_GetListOfLevelSequences");
static_assert(offsetof(PhxScriptedEventActor_GetListOfLevelSequences, ReturnValue) == 0x000000, "Member 'PhxScriptedEventActor_GetListOfLevelSequences::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.GetSyncPointFromBindingTag
// 0x0050 (0x0050 - 0x0000)
struct PhxScriptedEventActor_GetSyncPointFromBindingTag final
{
public:
	class FName                                   BindingTag;                                        // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Time;                                              // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTransform                             OutSyncPoint;                                      // 0x0010(0x0030)(Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0040(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_41[0xF];                                       // 0x0041(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxScriptedEventActor_GetSyncPointFromBindingTag) == 0x000010, "Wrong alignment on PhxScriptedEventActor_GetSyncPointFromBindingTag");
static_assert(sizeof(PhxScriptedEventActor_GetSyncPointFromBindingTag) == 0x000050, "Wrong size on PhxScriptedEventActor_GetSyncPointFromBindingTag");
static_assert(offsetof(PhxScriptedEventActor_GetSyncPointFromBindingTag, BindingTag) == 0x000000, "Member 'PhxScriptedEventActor_GetSyncPointFromBindingTag::BindingTag' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_GetSyncPointFromBindingTag, Time) == 0x000008, "Member 'PhxScriptedEventActor_GetSyncPointFromBindingTag::Time' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_GetSyncPointFromBindingTag, OutSyncPoint) == 0x000010, "Member 'PhxScriptedEventActor_GetSyncPointFromBindingTag::OutSyncPoint' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventActor_GetSyncPointFromBindingTag, ReturnValue) == 0x000040, "Member 'PhxScriptedEventActor_GetSyncPointFromBindingTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.HasValidCinematicData
// 0x0001 (0x0001 - 0x0000)
struct PhxScriptedEventActor_HasValidCinematicData final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_HasValidCinematicData) == 0x000001, "Wrong alignment on PhxScriptedEventActor_HasValidCinematicData");
static_assert(sizeof(PhxScriptedEventActor_HasValidCinematicData) == 0x000001, "Wrong size on PhxScriptedEventActor_HasValidCinematicData");
static_assert(offsetof(PhxScriptedEventActor_HasValidCinematicData, ReturnValue) == 0x000000, "Member 'PhxScriptedEventActor_HasValidCinematicData::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxScriptedEventActor.IsReadyForPlayback
// 0x0001 (0x0001 - 0x0000)
struct PhxScriptedEventActor_IsReadyForPlayback final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventActor_IsReadyForPlayback) == 0x000001, "Wrong alignment on PhxScriptedEventActor_IsReadyForPlayback");
static_assert(sizeof(PhxScriptedEventActor_IsReadyForPlayback) == 0x000001, "Wrong size on PhxScriptedEventActor_IsReadyForPlayback");
static_assert(offsetof(PhxScriptedEventActor_IsReadyForPlayback, ReturnValue) == 0x000000, "Member 'PhxScriptedEventActor_IsReadyForPlayback::ReturnValue' has a wrong offset!");

// Function Phoenix.EchoProjector.AreEchoComponentsReady
// 0x0001 (0x0001 - 0x0000)
struct EchoProjector_AreEchoComponentsReady final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoProjector_AreEchoComponentsReady) == 0x000001, "Wrong alignment on EchoProjector_AreEchoComponentsReady");
static_assert(sizeof(EchoProjector_AreEchoComponentsReady) == 0x000001, "Wrong size on EchoProjector_AreEchoComponentsReady");
static_assert(offsetof(EchoProjector_AreEchoComponentsReady, ReturnValue) == 0x000000, "Member 'EchoProjector_AreEchoComponentsReady::ReturnValue' has a wrong offset!");

// Function Phoenix.EchoProjector.OnInteractionAreaBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct EchoProjector_OnInteractionAreaBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoProjector_OnInteractionAreaBeginOverlap) == 0x000008, "Wrong alignment on EchoProjector_OnInteractionAreaBeginOverlap");
static_assert(sizeof(EchoProjector_OnInteractionAreaBeginOverlap) == 0x0000A8, "Wrong size on EchoProjector_OnInteractionAreaBeginOverlap");
static_assert(offsetof(EchoProjector_OnInteractionAreaBeginOverlap, OverlappedComponent) == 0x000000, "Member 'EchoProjector_OnInteractionAreaBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(EchoProjector_OnInteractionAreaBeginOverlap, OtherActor) == 0x000008, "Member 'EchoProjector_OnInteractionAreaBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(EchoProjector_OnInteractionAreaBeginOverlap, OtherComp) == 0x000010, "Member 'EchoProjector_OnInteractionAreaBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(EchoProjector_OnInteractionAreaBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'EchoProjector_OnInteractionAreaBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(EchoProjector_OnInteractionAreaBeginOverlap, bFromSweep) == 0x00001C, "Member 'EchoProjector_OnInteractionAreaBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(EchoProjector_OnInteractionAreaBeginOverlap, SweepResult) == 0x000020, "Member 'EchoProjector_OnInteractionAreaBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.EchoProjector.OnInteractionAreaEndOverlap
// 0x0020 (0x0020 - 0x0000)
struct EchoProjector_OnInteractionAreaEndOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(EchoProjector_OnInteractionAreaEndOverlap) == 0x000008, "Wrong alignment on EchoProjector_OnInteractionAreaEndOverlap");
static_assert(sizeof(EchoProjector_OnInteractionAreaEndOverlap) == 0x000020, "Wrong size on EchoProjector_OnInteractionAreaEndOverlap");
static_assert(offsetof(EchoProjector_OnInteractionAreaEndOverlap, OverlappedComponent) == 0x000000, "Member 'EchoProjector_OnInteractionAreaEndOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(EchoProjector_OnInteractionAreaEndOverlap, OtherActor) == 0x000008, "Member 'EchoProjector_OnInteractionAreaEndOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(EchoProjector_OnInteractionAreaEndOverlap, OtherComp) == 0x000010, "Member 'EchoProjector_OnInteractionAreaEndOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(EchoProjector_OnInteractionAreaEndOverlap, OtherBodyIndex) == 0x000018, "Member 'EchoProjector_OnInteractionAreaEndOverlap::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.EchoProjector.OnTriggerVolumeBeginOverlap
// 0x0010 (0x0010 - 0x0000)
struct EchoProjector_OnTriggerVolumeBeginOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoProjector_OnTriggerVolumeBeginOverlap) == 0x000008, "Wrong alignment on EchoProjector_OnTriggerVolumeBeginOverlap");
static_assert(sizeof(EchoProjector_OnTriggerVolumeBeginOverlap) == 0x000010, "Wrong size on EchoProjector_OnTriggerVolumeBeginOverlap");
static_assert(offsetof(EchoProjector_OnTriggerVolumeBeginOverlap, OverlappedActor) == 0x000000, "Member 'EchoProjector_OnTriggerVolumeBeginOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(EchoProjector_OnTriggerVolumeBeginOverlap, OtherActor) == 0x000008, "Member 'EchoProjector_OnTriggerVolumeBeginOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.EchoProjector.SetEchoAlertEnabled
// 0x0001 (0x0001 - 0x0000)
struct EchoProjector_SetEchoAlertEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoProjector_SetEchoAlertEnabled) == 0x000001, "Wrong alignment on EchoProjector_SetEchoAlertEnabled");
static_assert(sizeof(EchoProjector_SetEchoAlertEnabled) == 0x000001, "Wrong size on EchoProjector_SetEchoAlertEnabled");
static_assert(offsetof(EchoProjector_SetEchoAlertEnabled, bEnabled) == 0x000000, "Member 'EchoProjector_SetEchoAlertEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.EchoProjector.SetEchoUIControls
// 0x0001 (0x0001 - 0x0000)
struct EchoProjector_SetEchoUIControls final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoProjector_SetEchoUIControls) == 0x000001, "Wrong alignment on EchoProjector_SetEchoUIControls");
static_assert(sizeof(EchoProjector_SetEchoUIControls) == 0x000001, "Wrong size on EchoProjector_SetEchoUIControls");
static_assert(offsetof(EchoProjector_SetEchoUIControls, bEnabled) == 0x000000, "Member 'EchoProjector_SetEchoUIControls::bEnabled' has a wrong offset!");

// Function Phoenix.EchoProjector.GetEchoComponents
// 0x0010 (0x0010 - 0x0000)
struct EchoProjector_GetEchoComponents final
{
public:
	TArray<class UEchoComponent*>                 ReturnValue;                                       // 0x0000(0x0010)(ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoProjector_GetEchoComponents) == 0x000008, "Wrong alignment on EchoProjector_GetEchoComponents");
static_assert(sizeof(EchoProjector_GetEchoComponents) == 0x000010, "Wrong size on EchoProjector_GetEchoComponents");
static_assert(offsetof(EchoProjector_GetEchoComponents, ReturnValue) == 0x000000, "Member 'EchoProjector_GetEchoComponents::ReturnValue' has a wrong offset!");

// Function Phoenix.EchoState.BeginOverlap
// 0x0010 (0x0010 - 0x0000)
struct EchoState_BeginOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoState_BeginOverlap) == 0x000008, "Wrong alignment on EchoState_BeginOverlap");
static_assert(sizeof(EchoState_BeginOverlap) == 0x000010, "Wrong size on EchoState_BeginOverlap");
static_assert(offsetof(EchoState_BeginOverlap, OverlappedActor) == 0x000000, "Member 'EchoState_BeginOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(EchoState_BeginOverlap, OtherActor) == 0x000008, "Member 'EchoState_BeginOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.EchoUI.GetNormalizedDistanceToProjector
// 0x0004 (0x0004 - 0x0000)
struct EchoUI_GetNormalizedDistanceToProjector final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EchoUI_GetNormalizedDistanceToProjector) == 0x000004, "Wrong alignment on EchoUI_GetNormalizedDistanceToProjector");
static_assert(sizeof(EchoUI_GetNormalizedDistanceToProjector) == 0x000004, "Wrong size on EchoUI_GetNormalizedDistanceToProjector");
static_assert(offsetof(EchoUI_GetNormalizedDistanceToProjector, ReturnValue) == 0x000000, "Member 'EchoUI_GetNormalizedDistanceToProjector::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryWeaponDetails.SetDetailsVisible
// 0x0001 (0x0001 - 0x0000)
struct InventoryWeaponDetails_SetDetailsVisible final
{
public:
	bool                                          bVisible;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryWeaponDetails_SetDetailsVisible) == 0x000001, "Wrong alignment on InventoryWeaponDetails_SetDetailsVisible");
static_assert(sizeof(InventoryWeaponDetails_SetDetailsVisible) == 0x000001, "Wrong size on InventoryWeaponDetails_SetDetailsVisible");
static_assert(offsetof(InventoryWeaponDetails_SetDetailsVisible, bVisible) == 0x000000, "Member 'InventoryWeaponDetails_SetDetailsVisible::bVisible' has a wrong offset!");

// Function Phoenix.InventoryWeaponDetails.GetAdjacentSlot
// 0x0018 (0x0018 - 0x0000)
struct InventoryWeaponDetails_GetAdjacentSlot final
{
public:
	const class UInventorySlot*                   InSlot;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UInventorySlot*                         ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryWeaponDetails_GetAdjacentSlot) == 0x000008, "Wrong alignment on InventoryWeaponDetails_GetAdjacentSlot");
static_assert(sizeof(InventoryWeaponDetails_GetAdjacentSlot) == 0x000018, "Wrong size on InventoryWeaponDetails_GetAdjacentSlot");
static_assert(offsetof(InventoryWeaponDetails_GetAdjacentSlot, InSlot) == 0x000000, "Member 'InventoryWeaponDetails_GetAdjacentSlot::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryWeaponDetails_GetAdjacentSlot, Direction) == 0x000008, "Member 'InventoryWeaponDetails_GetAdjacentSlot::Direction' has a wrong offset!");
static_assert(offsetof(InventoryWeaponDetails_GetAdjacentSlot, ReturnValue) == 0x000010, "Member 'InventoryWeaponDetails_GetAdjacentSlot::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryWeaponDetails.GetSelectedSlot
// 0x0008 (0x0008 - 0x0000)
struct InventoryWeaponDetails_GetSelectedSlot final
{
public:
	class UInventorySlot*                         ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryWeaponDetails_GetSelectedSlot) == 0x000008, "Wrong alignment on InventoryWeaponDetails_GetSelectedSlot");
static_assert(sizeof(InventoryWeaponDetails_GetSelectedSlot) == 0x000008, "Wrong size on InventoryWeaponDetails_GetSelectedSlot");
static_assert(offsetof(InventoryWeaponDetails_GetSelectedSlot, ReturnValue) == 0x000000, "Member 'InventoryWeaponDetails_GetSelectedSlot::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLockPickPuzzle.HandleInteraction
// 0x0008 (0x0008 - 0x0000)
struct PhxLockPickPuzzle_HandleInteraction final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLockPickPuzzle_HandleInteraction) == 0x000008, "Wrong alignment on PhxLockPickPuzzle_HandleInteraction");
static_assert(sizeof(PhxLockPickPuzzle_HandleInteraction) == 0x000008, "Wrong size on PhxLockPickPuzzle_HandleInteraction");
static_assert(offsetof(PhxLockPickPuzzle_HandleInteraction, Character) == 0x000000, "Member 'PhxLockPickPuzzle_HandleInteraction::Character' has a wrong offset!");

// Function Phoenix.PhxSendEnemyDeathTelemetry.SendEnemyDeathTelemetry
// 0x0020 (0x0020 - 0x0000)
struct PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class APhxCharacter*                    Character;                                         // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class APhxCharacter*                    Enemy;                                             // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxSendEnemyDeathTelemetry*            ReturnValue;                                       // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry) == 0x000008, "Wrong alignment on PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry");
static_assert(sizeof(PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry) == 0x000020, "Wrong size on PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry");
static_assert(offsetof(PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry, WorldContextObject) == 0x000000, "Member 'PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry, Character) == 0x000008, "Member 'PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry::Character' has a wrong offset!");
static_assert(offsetof(PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry, Enemy) == 0x000010, "Member 'PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry::Enemy' has a wrong offset!");
static_assert(offsetof(PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry, ReturnValue) == 0x000018, "Member 'PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.CanInteract
// 0x0001 (0x0001 - 0x0000)
struct PhxPuzzleSwitch_CanInteract final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_CanInteract) == 0x000001, "Wrong alignment on PhxPuzzleSwitch_CanInteract");
static_assert(sizeof(PhxPuzzleSwitch_CanInteract) == 0x000001, "Wrong size on PhxPuzzleSwitch_CanInteract");
static_assert(offsetof(PhxPuzzleSwitch_CanInteract, ReturnValue) == 0x000000, "Member 'PhxPuzzleSwitch_CanInteract::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.IsPuzzleSolved
// 0x0001 (0x0001 - 0x0000)
struct PhxPuzzleSwitch_IsPuzzleSolved final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_IsPuzzleSolved) == 0x000001, "Wrong alignment on PhxPuzzleSwitch_IsPuzzleSolved");
static_assert(sizeof(PhxPuzzleSwitch_IsPuzzleSolved) == 0x000001, "Wrong size on PhxPuzzleSwitch_IsPuzzleSolved");
static_assert(offsetof(PhxPuzzleSwitch_IsPuzzleSolved, ReturnValue) == 0x000000, "Member 'PhxPuzzleSwitch_IsPuzzleSolved::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.OnAnimNotify
// 0x0001 (0x0001 - 0x0000)
struct PhxPuzzleSwitch_OnAnimNotify final
{
public:
	EPhxAnimNotify                                Notify;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_OnAnimNotify) == 0x000001, "Wrong alignment on PhxPuzzleSwitch_OnAnimNotify");
static_assert(sizeof(PhxPuzzleSwitch_OnAnimNotify) == 0x000001, "Wrong size on PhxPuzzleSwitch_OnAnimNotify");
static_assert(offsetof(PhxPuzzleSwitch_OnAnimNotify, Notify) == 0x000000, "Member 'PhxPuzzleSwitch_OnAnimNotify::Notify' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.OnFailedInteract
// 0x0008 (0x0008 - 0x0000)
struct PhxPuzzleSwitch_OnFailedInteract final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_OnFailedInteract) == 0x000008, "Wrong alignment on PhxPuzzleSwitch_OnFailedInteract");
static_assert(sizeof(PhxPuzzleSwitch_OnFailedInteract) == 0x000008, "Wrong size on PhxPuzzleSwitch_OnFailedInteract");
static_assert(offsetof(PhxPuzzleSwitch_OnFailedInteract, InteractedBy) == 0x000000, "Member 'PhxPuzzleSwitch_OnFailedInteract::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.OnInteract
// 0x0008 (0x0008 - 0x0000)
struct PhxPuzzleSwitch_OnInteract final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_OnInteract) == 0x000008, "Wrong alignment on PhxPuzzleSwitch_OnInteract");
static_assert(sizeof(PhxPuzzleSwitch_OnInteract) == 0x000008, "Wrong size on PhxPuzzleSwitch_OnInteract");
static_assert(offsetof(PhxPuzzleSwitch_OnInteract, InteractedBy) == 0x000000, "Member 'PhxPuzzleSwitch_OnInteract::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.PlayMontage
// 0x0008 (0x0008 - 0x0000)
struct PhxPuzzleSwitch_PlayMontage final
{
public:
	class FName                                   StartSectionName;                                  // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_PlayMontage) == 0x000004, "Wrong alignment on PhxPuzzleSwitch_PlayMontage");
static_assert(sizeof(PhxPuzzleSwitch_PlayMontage) == 0x000008, "Wrong size on PhxPuzzleSwitch_PlayMontage");
static_assert(offsetof(PhxPuzzleSwitch_PlayMontage, StartSectionName) == 0x000000, "Member 'PhxPuzzleSwitch_PlayMontage::StartSectionName' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.SetInteractionEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxPuzzleSwitch_SetInteractionEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_SetInteractionEnabled) == 0x000001, "Wrong alignment on PhxPuzzleSwitch_SetInteractionEnabled");
static_assert(sizeof(PhxPuzzleSwitch_SetInteractionEnabled) == 0x000001, "Wrong size on PhxPuzzleSwitch_SetInteractionEnabled");
static_assert(offsetof(PhxPuzzleSwitch_SetInteractionEnabled, bEnabled) == 0x000000, "Member 'PhxPuzzleSwitch_SetInteractionEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.SetState
// 0x0004 (0x0004 - 0x0000)
struct PhxPuzzleSwitch_SetState final
{
public:
	int32                                         NewState;                                          // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_SetState) == 0x000004, "Wrong alignment on PhxPuzzleSwitch_SetState");
static_assert(sizeof(PhxPuzzleSwitch_SetState) == 0x000004, "Wrong size on PhxPuzzleSwitch_SetState");
static_assert(offsetof(PhxPuzzleSwitch_SetState, NewState) == 0x000000, "Member 'PhxPuzzleSwitch_SetState::NewState' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.GetInteractionRequiresShiv
// 0x0001 (0x0001 - 0x0000)
struct PhxPuzzleSwitch_GetInteractionRequiresShiv final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_GetInteractionRequiresShiv) == 0x000001, "Wrong alignment on PhxPuzzleSwitch_GetInteractionRequiresShiv");
static_assert(sizeof(PhxPuzzleSwitch_GetInteractionRequiresShiv) == 0x000001, "Wrong size on PhxPuzzleSwitch_GetInteractionRequiresShiv");
static_assert(offsetof(PhxPuzzleSwitch_GetInteractionRequiresShiv, ReturnValue) == 0x000000, "Member 'PhxPuzzleSwitch_GetInteractionRequiresShiv::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.GetMontageSectionToPlayOnInteract
// 0x0008 (0x0008 - 0x0000)
struct PhxPuzzleSwitch_GetMontageSectionToPlayOnInteract final
{
public:
	class FName                                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_GetMontageSectionToPlayOnInteract) == 0x000004, "Wrong alignment on PhxPuzzleSwitch_GetMontageSectionToPlayOnInteract");
static_assert(sizeof(PhxPuzzleSwitch_GetMontageSectionToPlayOnInteract) == 0x000008, "Wrong size on PhxPuzzleSwitch_GetMontageSectionToPlayOnInteract");
static_assert(offsetof(PhxPuzzleSwitch_GetMontageSectionToPlayOnInteract, ReturnValue) == 0x000000, "Member 'PhxPuzzleSwitch_GetMontageSectionToPlayOnInteract::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.GetMontageSectionToPlayOnStart
// 0x0008 (0x0008 - 0x0000)
struct PhxPuzzleSwitch_GetMontageSectionToPlayOnStart final
{
public:
	class FName                                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_GetMontageSectionToPlayOnStart) == 0x000004, "Wrong alignment on PhxPuzzleSwitch_GetMontageSectionToPlayOnStart");
static_assert(sizeof(PhxPuzzleSwitch_GetMontageSectionToPlayOnStart) == 0x000008, "Wrong size on PhxPuzzleSwitch_GetMontageSectionToPlayOnStart");
static_assert(offsetof(PhxPuzzleSwitch_GetMontageSectionToPlayOnStart, ReturnValue) == 0x000000, "Member 'PhxPuzzleSwitch_GetMontageSectionToPlayOnStart::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.GetSkeletalMesh
// 0x0008 (0x0008 - 0x0000)
struct PhxPuzzleSwitch_GetSkeletalMesh final
{
public:
	class USkeletalMeshComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_GetSkeletalMesh) == 0x000008, "Wrong alignment on PhxPuzzleSwitch_GetSkeletalMesh");
static_assert(sizeof(PhxPuzzleSwitch_GetSkeletalMesh) == 0x000008, "Wrong size on PhxPuzzleSwitch_GetSkeletalMesh");
static_assert(offsetof(PhxPuzzleSwitch_GetSkeletalMesh, ReturnValue) == 0x000000, "Member 'PhxPuzzleSwitch_GetSkeletalMesh::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPuzzleSwitch.GetState
// 0x0004 (0x0004 - 0x0000)
struct PhxPuzzleSwitch_GetState final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleSwitch_GetState) == 0x000004, "Wrong alignment on PhxPuzzleSwitch_GetState");
static_assert(sizeof(PhxPuzzleSwitch_GetState) == 0x000004, "Wrong size on PhxPuzzleSwitch_GetState");
static_assert(offsetof(PhxPuzzleSwitch_GetState, ReturnValue) == 0x000000, "Member 'PhxPuzzleSwitch_GetState::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPuzzleCrate.HandleProximityChanged
// 0x0002 (0x0002 - 0x0000)
struct PhxPuzzleCrate_HandleProximityChanged final
{
public:
	EInteractableProximity                        Promity;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInteractableProximity                        PreviousProximity;                                 // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleCrate_HandleProximityChanged) == 0x000001, "Wrong alignment on PhxPuzzleCrate_HandleProximityChanged");
static_assert(sizeof(PhxPuzzleCrate_HandleProximityChanged) == 0x000002, "Wrong size on PhxPuzzleCrate_HandleProximityChanged");
static_assert(offsetof(PhxPuzzleCrate_HandleProximityChanged, Promity) == 0x000000, "Member 'PhxPuzzleCrate_HandleProximityChanged::Promity' has a wrong offset!");
static_assert(offsetof(PhxPuzzleCrate_HandleProximityChanged, PreviousProximity) == 0x000001, "Member 'PhxPuzzleCrate_HandleProximityChanged::PreviousProximity' has a wrong offset!");

// Function Phoenix.PhxPuzzleCrate.OnCrateCollided
// 0x0088 (0x0088 - 0x0000)
struct PhxPuzzleCrate_OnCrateCollided final
{
public:
	struct FHitResult                             HitInfo;                                           // 0x0000(0x0088)(Parm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleCrate_OnCrateCollided) == 0x000004, "Wrong alignment on PhxPuzzleCrate_OnCrateCollided");
static_assert(sizeof(PhxPuzzleCrate_OnCrateCollided) == 0x000088, "Wrong size on PhxPuzzleCrate_OnCrateCollided");
static_assert(offsetof(PhxPuzzleCrate_OnCrateCollided, HitInfo) == 0x000000, "Member 'PhxPuzzleCrate_OnCrateCollided::HitInfo' has a wrong offset!");

// Function Phoenix.PhxPuzzleCrate.SetState
// 0x0001 (0x0001 - 0x0000)
struct PhxPuzzleCrate_SetState final
{
public:
	EMovableCrateState                            State;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleCrate_SetState) == 0x000001, "Wrong alignment on PhxPuzzleCrate_SetState");
static_assert(sizeof(PhxPuzzleCrate_SetState) == 0x000001, "Wrong size on PhxPuzzleCrate_SetState");
static_assert(offsetof(PhxPuzzleCrate_SetState, State) == 0x000000, "Member 'PhxPuzzleCrate_SetState::State' has a wrong offset!");

// Function Phoenix.HDRGammaScreenWidget.SetBlackPointCorrectionSliderPosition
// 0x0008 (0x0008 - 0x0000)
struct HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bBroadcast;                                        // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition) == 0x000004, "Wrong alignment on HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition");
static_assert(sizeof(HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition) == 0x000008, "Wrong size on HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition");
static_assert(offsetof(HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition, InValue) == 0x000000, "Member 'HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition::InValue' has a wrong offset!");
static_assert(offsetof(HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition, bBroadcast) == 0x000004, "Member 'HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition::bBroadcast' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.Compare
// 0x0028 (0x0028 - 0x0000)
struct PhxSaveGameButton_Compare final
{
public:
	struct FDateTime                              InTime;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FText                                   InName;                                            // 0x0008(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0020(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x7];                                       // 0x0021(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameButton_Compare) == 0x000008, "Wrong alignment on PhxSaveGameButton_Compare");
static_assert(sizeof(PhxSaveGameButton_Compare) == 0x000028, "Wrong size on PhxSaveGameButton_Compare");
static_assert(offsetof(PhxSaveGameButton_Compare, InTime) == 0x000000, "Member 'PhxSaveGameButton_Compare::InTime' has a wrong offset!");
static_assert(offsetof(PhxSaveGameButton_Compare, InName) == 0x000008, "Member 'PhxSaveGameButton_Compare::InName' has a wrong offset!");
static_assert(offsetof(PhxSaveGameButton_Compare, ReturnValue) == 0x000020, "Member 'PhxSaveGameButton_Compare::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetDate
// 0x0018 (0x0018 - 0x0000)
struct PhxSaveGameButton_SetDate final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetDate) == 0x000008, "Wrong alignment on PhxSaveGameButton_SetDate");
static_assert(sizeof(PhxSaveGameButton_SetDate) == 0x000018, "Wrong size on PhxSaveGameButton_SetDate");
static_assert(offsetof(PhxSaveGameButton_SetDate, InText) == 0x000000, "Member 'PhxSaveGameButton_SetDate::InText' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetGameType
// 0x0018 (0x0018 - 0x0000)
struct PhxSaveGameButton_SetGameType final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetGameType) == 0x000008, "Wrong alignment on PhxSaveGameButton_SetGameType");
static_assert(sizeof(PhxSaveGameButton_SetGameType) == 0x000018, "Wrong size on PhxSaveGameButton_SetGameType");
static_assert(offsetof(PhxSaveGameButton_SetGameType, InText) == 0x000000, "Member 'PhxSaveGameButton_SetGameType::InText' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetLevel
// 0x0018 (0x0018 - 0x0000)
struct PhxSaveGameButton_SetLevel final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetLevel) == 0x000008, "Wrong alignment on PhxSaveGameButton_SetLevel");
static_assert(sizeof(PhxSaveGameButton_SetLevel) == 0x000018, "Wrong size on PhxSaveGameButton_SetLevel");
static_assert(offsetof(PhxSaveGameButton_SetLevel, InText) == 0x000000, "Member 'PhxSaveGameButton_SetLevel::InText' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetLocation
// 0x0018 (0x0018 - 0x0000)
struct PhxSaveGameButton_SetLocation final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetLocation) == 0x000008, "Wrong alignment on PhxSaveGameButton_SetLocation");
static_assert(sizeof(PhxSaveGameButton_SetLocation) == 0x000018, "Wrong size on PhxSaveGameButton_SetLocation");
static_assert(offsetof(PhxSaveGameButton_SetLocation, InText) == 0x000000, "Member 'PhxSaveGameButton_SetLocation::InText' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetModifiedTime
// 0x0008 (0x0008 - 0x0000)
struct PhxSaveGameButton_SetModifiedTime final
{
public:
	struct FDateTime                              InTime;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetModifiedTime) == 0x000008, "Wrong alignment on PhxSaveGameButton_SetModifiedTime");
static_assert(sizeof(PhxSaveGameButton_SetModifiedTime) == 0x000008, "Wrong size on PhxSaveGameButton_SetModifiedTime");
static_assert(offsetof(PhxSaveGameButton_SetModifiedTime, InTime) == 0x000000, "Member 'PhxSaveGameButton_SetModifiedTime::InTime' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetName
// 0x0018 (0x0018 - 0x0000)
struct PhxSaveGameButton_SetName final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetName) == 0x000008, "Wrong alignment on PhxSaveGameButton_SetName");
static_assert(sizeof(PhxSaveGameButton_SetName) == 0x000018, "Wrong size on PhxSaveGameButton_SetName");
static_assert(offsetof(PhxSaveGameButton_SetName, InText) == 0x000000, "Member 'PhxSaveGameButton_SetName::InText' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetSaveSlotName
// 0x0010 (0x0010 - 0x0000)
struct PhxSaveGameButton_SetSaveSlotName final
{
public:
	class FString                                 inString;                                          // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetSaveSlotName) == 0x000008, "Wrong alignment on PhxSaveGameButton_SetSaveSlotName");
static_assert(sizeof(PhxSaveGameButton_SetSaveSlotName) == 0x000010, "Wrong size on PhxSaveGameButton_SetSaveSlotName");
static_assert(offsetof(PhxSaveGameButton_SetSaveSlotName, inString) == 0x000000, "Member 'PhxSaveGameButton_SetSaveSlotName::inString' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetSaveType
// 0x0001 (0x0001 - 0x0000)
struct PhxSaveGameButton_SetSaveType final
{
public:
	EPhxSaveGameType                              InSaveType;                                        // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetSaveType) == 0x000001, "Wrong alignment on PhxSaveGameButton_SetSaveType");
static_assert(sizeof(PhxSaveGameButton_SetSaveType) == 0x000001, "Wrong size on PhxSaveGameButton_SetSaveType");
static_assert(offsetof(PhxSaveGameButton_SetSaveType, InSaveType) == 0x000000, "Member 'PhxSaveGameButton_SetSaveType::InSaveType' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetTime
// 0x0018 (0x0018 - 0x0000)
struct PhxSaveGameButton_SetTime final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetTime) == 0x000008, "Wrong alignment on PhxSaveGameButton_SetTime");
static_assert(sizeof(PhxSaveGameButton_SetTime) == 0x000018, "Wrong size on PhxSaveGameButton_SetTime");
static_assert(offsetof(PhxSaveGameButton_SetTime, InText) == 0x000000, "Member 'PhxSaveGameButton_SetTime::InText' has a wrong offset!");

// Function Phoenix.PhxSaveGameButton.SetTotalPlayTime
// 0x0004 (0x0004 - 0x0000)
struct PhxSaveGameButton_SetTotalPlayTime final
{
public:
	float                                         InTime;                                            // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameButton_SetTotalPlayTime) == 0x000004, "Wrong alignment on PhxSaveGameButton_SetTotalPlayTime");
static_assert(sizeof(PhxSaveGameButton_SetTotalPlayTime) == 0x000004, "Wrong size on PhxSaveGameButton_SetTotalPlayTime");
static_assert(offsetof(PhxSaveGameButton_SetTotalPlayTime, InTime) == 0x000000, "Member 'PhxSaveGameButton_SetTotalPlayTime::InTime' has a wrong offset!");

// Function Phoenix.PhxSplineMesh.GetSpline
// 0x0008 (0x0008 - 0x0000)
struct PhxSplineMesh_GetSpline final
{
public:
	class USplineComponent*                       ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSplineMesh_GetSpline) == 0x000008, "Wrong alignment on PhxSplineMesh_GetSpline");
static_assert(sizeof(PhxSplineMesh_GetSpline) == 0x000008, "Wrong size on PhxSplineMesh_GetSpline");
static_assert(offsetof(PhxSplineMesh_GetSpline, ReturnValue) == 0x000000, "Member 'PhxSplineMesh_GetSpline::ReturnValue' has a wrong offset!");

// Function Phoenix.GlowNode.OnPerceived
// 0x0048 (0x0048 - 0x0000)
struct GlowNode_OnPerceived final
{
public:
	class AActor*                                 Actor;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FAIStimulus                            Stimulus;                                          // 0x0008(0x003C)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(GlowNode_OnPerceived) == 0x000008, "Wrong alignment on GlowNode_OnPerceived");
static_assert(sizeof(GlowNode_OnPerceived) == 0x000048, "Wrong size on GlowNode_OnPerceived");
static_assert(offsetof(GlowNode_OnPerceived, Actor) == 0x000000, "Member 'GlowNode_OnPerceived::Actor' has a wrong offset!");
static_assert(offsetof(GlowNode_OnPerceived, Stimulus) == 0x000008, "Member 'GlowNode_OnPerceived::Stimulus' has a wrong offset!");

// Function Phoenix.TargetComponent.SetIsMeleeTargetable
// 0x0001 (0x0001 - 0x0000)
struct TargetComponent_SetIsMeleeTargetable final
{
public:
	bool                                          bTargetable;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TargetComponent_SetIsMeleeTargetable) == 0x000001, "Wrong alignment on TargetComponent_SetIsMeleeTargetable");
static_assert(sizeof(TargetComponent_SetIsMeleeTargetable) == 0x000001, "Wrong size on TargetComponent_SetIsMeleeTargetable");
static_assert(offsetof(TargetComponent_SetIsMeleeTargetable, bTargetable) == 0x000000, "Member 'TargetComponent_SetIsMeleeTargetable::bTargetable' has a wrong offset!");

// Function Phoenix.TargetComponent.GetIsMeleeTargetable
// 0x0001 (0x0001 - 0x0000)
struct TargetComponent_GetIsMeleeTargetable final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TargetComponent_GetIsMeleeTargetable) == 0x000001, "Wrong alignment on TargetComponent_GetIsMeleeTargetable");
static_assert(sizeof(TargetComponent_GetIsMeleeTargetable) == 0x000001, "Wrong size on TargetComponent_GetIsMeleeTargetable");
static_assert(offsetof(TargetComponent_GetIsMeleeTargetable, ReturnValue) == 0x000000, "Member 'TargetComponent_GetIsMeleeTargetable::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCameraManager.DelayCameraFade
// 0x0024 (0x0024 - 0x0000)
struct PhxPlayerCameraManager_DelayCameraFade final
{
public:
	float                                         DelayDuration;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FromAlpha;                                         // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ToAlpha;                                           // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Duration;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           Color;                                             // 0x0010(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShouldFadeAudio;                                  // 0x0020(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bHoldWhenFinished;                                 // 0x0021(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_22[0x2];                                       // 0x0022(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerCameraManager_DelayCameraFade) == 0x000004, "Wrong alignment on PhxPlayerCameraManager_DelayCameraFade");
static_assert(sizeof(PhxPlayerCameraManager_DelayCameraFade) == 0x000024, "Wrong size on PhxPlayerCameraManager_DelayCameraFade");
static_assert(offsetof(PhxPlayerCameraManager_DelayCameraFade, DelayDuration) == 0x000000, "Member 'PhxPlayerCameraManager_DelayCameraFade::DelayDuration' has a wrong offset!");
static_assert(offsetof(PhxPlayerCameraManager_DelayCameraFade, FromAlpha) == 0x000004, "Member 'PhxPlayerCameraManager_DelayCameraFade::FromAlpha' has a wrong offset!");
static_assert(offsetof(PhxPlayerCameraManager_DelayCameraFade, ToAlpha) == 0x000008, "Member 'PhxPlayerCameraManager_DelayCameraFade::ToAlpha' has a wrong offset!");
static_assert(offsetof(PhxPlayerCameraManager_DelayCameraFade, Duration) == 0x00000C, "Member 'PhxPlayerCameraManager_DelayCameraFade::Duration' has a wrong offset!");
static_assert(offsetof(PhxPlayerCameraManager_DelayCameraFade, Color) == 0x000010, "Member 'PhxPlayerCameraManager_DelayCameraFade::Color' has a wrong offset!");
static_assert(offsetof(PhxPlayerCameraManager_DelayCameraFade, bShouldFadeAudio) == 0x000020, "Member 'PhxPlayerCameraManager_DelayCameraFade::bShouldFadeAudio' has a wrong offset!");
static_assert(offsetof(PhxPlayerCameraManager_DelayCameraFade, bHoldWhenFinished) == 0x000021, "Member 'PhxPlayerCameraManager_DelayCameraFade::bHoldWhenFinished' has a wrong offset!");

// Function Phoenix.PhxPlayerCameraManager.GetCurrentPitchPercentOfMaxSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCameraManager_GetCurrentPitchPercentOfMaxSpeed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCameraManager_GetCurrentPitchPercentOfMaxSpeed) == 0x000004, "Wrong alignment on PhxPlayerCameraManager_GetCurrentPitchPercentOfMaxSpeed");
static_assert(sizeof(PhxPlayerCameraManager_GetCurrentPitchPercentOfMaxSpeed) == 0x000004, "Wrong size on PhxPlayerCameraManager_GetCurrentPitchPercentOfMaxSpeed");
static_assert(offsetof(PhxPlayerCameraManager_GetCurrentPitchPercentOfMaxSpeed, ReturnValue) == 0x000000, "Member 'PhxPlayerCameraManager_GetCurrentPitchPercentOfMaxSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCameraManager.GetCurrentPitchSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCameraManager_GetCurrentPitchSpeed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCameraManager_GetCurrentPitchSpeed) == 0x000004, "Wrong alignment on PhxPlayerCameraManager_GetCurrentPitchSpeed");
static_assert(sizeof(PhxPlayerCameraManager_GetCurrentPitchSpeed) == 0x000004, "Wrong size on PhxPlayerCameraManager_GetCurrentPitchSpeed");
static_assert(offsetof(PhxPlayerCameraManager_GetCurrentPitchSpeed, ReturnValue) == 0x000000, "Member 'PhxPlayerCameraManager_GetCurrentPitchSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCameraManager.GetCurrentYawPercentOfMaxSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCameraManager_GetCurrentYawPercentOfMaxSpeed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCameraManager_GetCurrentYawPercentOfMaxSpeed) == 0x000004, "Wrong alignment on PhxPlayerCameraManager_GetCurrentYawPercentOfMaxSpeed");
static_assert(sizeof(PhxPlayerCameraManager_GetCurrentYawPercentOfMaxSpeed) == 0x000004, "Wrong size on PhxPlayerCameraManager_GetCurrentYawPercentOfMaxSpeed");
static_assert(offsetof(PhxPlayerCameraManager_GetCurrentYawPercentOfMaxSpeed, ReturnValue) == 0x000000, "Member 'PhxPlayerCameraManager_GetCurrentYawPercentOfMaxSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCameraManager.GetCurrentYawSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCameraManager_GetCurrentYawSpeed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCameraManager_GetCurrentYawSpeed) == 0x000004, "Wrong alignment on PhxPlayerCameraManager_GetCurrentYawSpeed");
static_assert(sizeof(PhxPlayerCameraManager_GetCurrentYawSpeed) == 0x000004, "Wrong size on PhxPlayerCameraManager_GetCurrentYawSpeed");
static_assert(offsetof(PhxPlayerCameraManager_GetCurrentYawSpeed, ReturnValue) == 0x000000, "Member 'PhxPlayerCameraManager_GetCurrentYawSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCameraManager.GetMaxPitchSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCameraManager_GetMaxPitchSpeed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCameraManager_GetMaxPitchSpeed) == 0x000004, "Wrong alignment on PhxPlayerCameraManager_GetMaxPitchSpeed");
static_assert(sizeof(PhxPlayerCameraManager_GetMaxPitchSpeed) == 0x000004, "Wrong size on PhxPlayerCameraManager_GetMaxPitchSpeed");
static_assert(offsetof(PhxPlayerCameraManager_GetMaxPitchSpeed, ReturnValue) == 0x000000, "Member 'PhxPlayerCameraManager_GetMaxPitchSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCameraManager.GetMaxYawSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCameraManager_GetMaxYawSpeed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCameraManager_GetMaxYawSpeed) == 0x000004, "Wrong alignment on PhxPlayerCameraManager_GetMaxYawSpeed");
static_assert(sizeof(PhxPlayerCameraManager_GetMaxYawSpeed) == 0x000004, "Wrong size on PhxPlayerCameraManager_GetMaxYawSpeed");
static_assert(offsetof(PhxPlayerCameraManager_GetMaxYawSpeed, ReturnValue) == 0x000000, "Member 'PhxPlayerCameraManager_GetMaxYawSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCameraManager.GetCurrentFadeAmount
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCameraManager_GetCurrentFadeAmount final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCameraManager_GetCurrentFadeAmount) == 0x000004, "Wrong alignment on PhxPlayerCameraManager_GetCurrentFadeAmount");
static_assert(sizeof(PhxPlayerCameraManager_GetCurrentFadeAmount) == 0x000004, "Wrong size on PhxPlayerCameraManager_GetCurrentFadeAmount");
static_assert(offsetof(PhxPlayerCameraManager_GetCurrentFadeAmount, ReturnValue) == 0x000000, "Member 'PhxPlayerCameraManager_GetCurrentFadeAmount::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRangedWeapon.OnHit
// 0x00B8 (0x00B8 - 0x0000)
struct PhxRangedWeapon_OnHit final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TheBaseDamage;                                     // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                HitFromDirection;                                  // 0x000C(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             HitInfo;                                           // 0x0018(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	class AController*                            EventInstigator;                                   // 0x00A0(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x00A8(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UDamageType>                DamageTypeClass;                                   // 0x00B0(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRangedWeapon_OnHit) == 0x000008, "Wrong alignment on PhxRangedWeapon_OnHit");
static_assert(sizeof(PhxRangedWeapon_OnHit) == 0x0000B8, "Wrong size on PhxRangedWeapon_OnHit");
static_assert(offsetof(PhxRangedWeapon_OnHit, DamagedActor) == 0x000000, "Member 'PhxRangedWeapon_OnHit::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxRangedWeapon_OnHit, TheBaseDamage) == 0x000008, "Member 'PhxRangedWeapon_OnHit::TheBaseDamage' has a wrong offset!");
static_assert(offsetof(PhxRangedWeapon_OnHit, HitFromDirection) == 0x00000C, "Member 'PhxRangedWeapon_OnHit::HitFromDirection' has a wrong offset!");
static_assert(offsetof(PhxRangedWeapon_OnHit, HitInfo) == 0x000018, "Member 'PhxRangedWeapon_OnHit::HitInfo' has a wrong offset!");
static_assert(offsetof(PhxRangedWeapon_OnHit, EventInstigator) == 0x0000A0, "Member 'PhxRangedWeapon_OnHit::EventInstigator' has a wrong offset!");
static_assert(offsetof(PhxRangedWeapon_OnHit, DamageCauser) == 0x0000A8, "Member 'PhxRangedWeapon_OnHit::DamageCauser' has a wrong offset!");
static_assert(offsetof(PhxRangedWeapon_OnHit, DamageTypeClass) == 0x0000B0, "Member 'PhxRangedWeapon_OnHit::DamageTypeClass' has a wrong offset!");

// Function Phoenix.PhxRangedWeapon.GetAmmoComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxRangedWeapon_GetAmmoComponent final
{
public:
	class UPhxAmmoComponent*                      ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRangedWeapon_GetAmmoComponent) == 0x000008, "Wrong alignment on PhxRangedWeapon_GetAmmoComponent");
static_assert(sizeof(PhxRangedWeapon_GetAmmoComponent) == 0x000008, "Wrong size on PhxRangedWeapon_GetAmmoComponent");
static_assert(offsetof(PhxRangedWeapon_GetAmmoComponent, ReturnValue) == 0x000000, "Member 'PhxRangedWeapon_GetAmmoComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRangedWeapon.GetIsFiring
// 0x0001 (0x0001 - 0x0000)
struct PhxRangedWeapon_GetIsFiring final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRangedWeapon_GetIsFiring) == 0x000001, "Wrong alignment on PhxRangedWeapon_GetIsFiring");
static_assert(sizeof(PhxRangedWeapon_GetIsFiring) == 0x000001, "Wrong size on PhxRangedWeapon_GetIsFiring");
static_assert(offsetof(PhxRangedWeapon_GetIsFiring, ReturnValue) == 0x000000, "Member 'PhxRangedWeapon_GetIsFiring::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRangedWeapon.GetIsInADS
// 0x0001 (0x0001 - 0x0000)
struct PhxRangedWeapon_GetIsInADS final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRangedWeapon_GetIsInADS) == 0x000001, "Wrong alignment on PhxRangedWeapon_GetIsInADS");
static_assert(sizeof(PhxRangedWeapon_GetIsInADS) == 0x000001, "Wrong size on PhxRangedWeapon_GetIsInADS");
static_assert(offsetof(PhxRangedWeapon_GetIsInADS, ReturnValue) == 0x000000, "Member 'PhxRangedWeapon_GetIsInADS::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRangedWeapon.GetOwningCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxRangedWeapon_GetOwningCharacter final
{
public:
	class APhxCharacter*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRangedWeapon_GetOwningCharacter) == 0x000008, "Wrong alignment on PhxRangedWeapon_GetOwningCharacter");
static_assert(sizeof(PhxRangedWeapon_GetOwningCharacter) == 0x000008, "Wrong size on PhxRangedWeapon_GetOwningCharacter");
static_assert(offsetof(PhxRangedWeapon_GetOwningCharacter, ReturnValue) == 0x000000, "Member 'PhxRangedWeapon_GetOwningCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.GRPWeapon.BP_UpdateChargeVisuals
// 0x0004 (0x0004 - 0x0000)
struct GRPWeapon_BP_UpdateChargeVisuals final
{
public:
	float                                         ChargeLevel;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPWeapon_BP_UpdateChargeVisuals) == 0x000004, "Wrong alignment on GRPWeapon_BP_UpdateChargeVisuals");
static_assert(sizeof(GRPWeapon_BP_UpdateChargeVisuals) == 0x000004, "Wrong size on GRPWeapon_BP_UpdateChargeVisuals");
static_assert(offsetof(GRPWeapon_BP_UpdateChargeVisuals, ChargeLevel) == 0x000000, "Member 'GRPWeapon_BP_UpdateChargeVisuals::ChargeLevel' has a wrong offset!");

// Function Phoenix.GRPWeapon.GetGRPRechargeDelayAlpha
// 0x0004 (0x0004 - 0x0000)
struct GRPWeapon_GetGRPRechargeDelayAlpha final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPWeapon_GetGRPRechargeDelayAlpha) == 0x000004, "Wrong alignment on GRPWeapon_GetGRPRechargeDelayAlpha");
static_assert(sizeof(GRPWeapon_GetGRPRechargeDelayAlpha) == 0x000004, "Wrong size on GRPWeapon_GetGRPRechargeDelayAlpha");
static_assert(offsetof(GRPWeapon_GetGRPRechargeDelayAlpha, ReturnValue) == 0x000000, "Member 'GRPWeapon_GetGRPRechargeDelayAlpha::ReturnValue' has a wrong offset!");

// Function Phoenix.GRPWeapon.OnGRPWeaponRelease
// 0x0001 (0x0001 - 0x0000)
struct GRPWeapon_OnGRPWeaponRelease final
{
public:
	EGRPReleaseReason                             ReleaseReason;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPWeapon_OnGRPWeaponRelease) == 0x000001, "Wrong alignment on GRPWeapon_OnGRPWeaponRelease");
static_assert(sizeof(GRPWeapon_OnGRPWeaponRelease) == 0x000001, "Wrong size on GRPWeapon_OnGRPWeaponRelease");
static_assert(offsetof(GRPWeapon_OnGRPWeaponRelease, ReleaseReason) == 0x000000, "Member 'GRPWeapon_OnGRPWeaponRelease::ReleaseReason' has a wrong offset!");

// Function Phoenix.GRPWeapon.GetChargeComponent
// 0x0008 (0x0008 - 0x0000)
struct GRPWeapon_GetChargeComponent final
{
public:
	class UGRPChargeComponent*                    ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPWeapon_GetChargeComponent) == 0x000008, "Wrong alignment on GRPWeapon_GetChargeComponent");
static_assert(sizeof(GRPWeapon_GetChargeComponent) == 0x000008, "Wrong size on GRPWeapon_GetChargeComponent");
static_assert(offsetof(GRPWeapon_GetChargeComponent, ReturnValue) == 0x000000, "Member 'GRPWeapon_GetChargeComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.GRPWeapon.GetGRPLaunchLevel
// 0x0001 (0x0001 - 0x0000)
struct GRPWeapon_GetGRPLaunchLevel final
{
public:
	EGRPLaunchLevel                               ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPWeapon_GetGRPLaunchLevel) == 0x000001, "Wrong alignment on GRPWeapon_GetGRPLaunchLevel");
static_assert(sizeof(GRPWeapon_GetGRPLaunchLevel) == 0x000001, "Wrong size on GRPWeapon_GetGRPLaunchLevel");
static_assert(offsetof(GRPWeapon_GetGRPLaunchLevel, ReturnValue) == 0x000000, "Member 'GRPWeapon_GetGRPLaunchLevel::ReturnValue' has a wrong offset!");

// Function Phoenix.GRPWeapon.GetGRPTarget
// 0x0008 (0x0008 - 0x0000)
struct GRPWeapon_GetGRPTarget final
{
public:
	class AActor*                                 ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPWeapon_GetGRPTarget) == 0x000008, "Wrong alignment on GRPWeapon_GetGRPTarget");
static_assert(sizeof(GRPWeapon_GetGRPTarget) == 0x000008, "Wrong size on GRPWeapon_GetGRPTarget");
static_assert(offsetof(GRPWeapon_GetGRPTarget, ReturnValue) == 0x000000, "Member 'GRPWeapon_GetGRPTarget::ReturnValue' has a wrong offset!");

// Function Phoenix.GRPWeapon.GetGRPWeaponHoldAttachOffset
// 0x000C (0x000C - 0x0000)
struct GRPWeapon_GetGRPWeaponHoldAttachOffset final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPWeapon_GetGRPWeaponHoldAttachOffset) == 0x000004, "Wrong alignment on GRPWeapon_GetGRPWeaponHoldAttachOffset");
static_assert(sizeof(GRPWeapon_GetGRPWeaponHoldAttachOffset) == 0x00000C, "Wrong size on GRPWeapon_GetGRPWeaponHoldAttachOffset");
static_assert(offsetof(GRPWeapon_GetGRPWeaponHoldAttachOffset, ReturnValue) == 0x000000, "Member 'GRPWeapon_GetGRPWeaponHoldAttachOffset::ReturnValue' has a wrong offset!");

// Function Phoenix.GRPWeapon.GetGRPWeaponSocketLocationAndRotation
// 0x0030 (0x0030 - 0x0000)
struct GRPWeapon_GetGRPWeaponSocketLocationAndRotation final
{
public:
	class FName                                   SocketName;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                OutLocation;                                       // 0x0008(0x000C)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0xC];                                       // 0x0014(0x000C)(Fixing Size After Last Property [ Dumper-7 ])
	struct FQuat                                  OutRotation;                                       // 0x0020(0x0010)(Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(GRPWeapon_GetGRPWeaponSocketLocationAndRotation) == 0x000010, "Wrong alignment on GRPWeapon_GetGRPWeaponSocketLocationAndRotation");
static_assert(sizeof(GRPWeapon_GetGRPWeaponSocketLocationAndRotation) == 0x000030, "Wrong size on GRPWeapon_GetGRPWeaponSocketLocationAndRotation");
static_assert(offsetof(GRPWeapon_GetGRPWeaponSocketLocationAndRotation, SocketName) == 0x000000, "Member 'GRPWeapon_GetGRPWeaponSocketLocationAndRotation::SocketName' has a wrong offset!");
static_assert(offsetof(GRPWeapon_GetGRPWeaponSocketLocationAndRotation, OutLocation) == 0x000008, "Member 'GRPWeapon_GetGRPWeaponSocketLocationAndRotation::OutLocation' has a wrong offset!");
static_assert(offsetof(GRPWeapon_GetGRPWeaponSocketLocationAndRotation, OutRotation) == 0x000020, "Member 'GRPWeapon_GetGRPWeaponSocketLocationAndRotation::OutRotation' has a wrong offset!");

// Function Phoenix.HarvestableComponent.FinishHarvest
// 0x0008 (0x0008 - 0x0000)
struct HarvestableComponent_FinishHarvest final
{
public:
	class APhxCharacter*                          Harvester;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HarvestableComponent_FinishHarvest) == 0x000008, "Wrong alignment on HarvestableComponent_FinishHarvest");
static_assert(sizeof(HarvestableComponent_FinishHarvest) == 0x000008, "Wrong size on HarvestableComponent_FinishHarvest");
static_assert(offsetof(HarvestableComponent_FinishHarvest, Harvester) == 0x000000, "Member 'HarvestableComponent_FinishHarvest::Harvester' has a wrong offset!");

// Function Phoenix.HarvestableComponent.OnOwnerDeath
// 0x0008 (0x0008 - 0x0000)
struct HarvestableComponent_OnOwnerDeath final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HarvestableComponent_OnOwnerDeath) == 0x000008, "Wrong alignment on HarvestableComponent_OnOwnerDeath");
static_assert(sizeof(HarvestableComponent_OnOwnerDeath) == 0x000008, "Wrong size on HarvestableComponent_OnOwnerDeath");
static_assert(offsetof(HarvestableComponent_OnOwnerDeath, DeadCharacter) == 0x000000, "Member 'HarvestableComponent_OnOwnerDeath::DeadCharacter' has a wrong offset!");

// Function Phoenix.PhxStompableInterface.CanTakeStompDamage
// 0x0001 (0x0001 - 0x0000)
struct PhxStompableInterface_CanTakeStompDamage final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxStompableInterface_CanTakeStompDamage) == 0x000001, "Wrong alignment on PhxStompableInterface_CanTakeStompDamage");
static_assert(sizeof(PhxStompableInterface_CanTakeStompDamage) == 0x000001, "Wrong size on PhxStompableInterface_CanTakeStompDamage");
static_assert(offsetof(PhxStompableInterface_CanTakeStompDamage, ReturnValue) == 0x000000, "Member 'PhxStompableInterface_CanTakeStompDamage::ReturnValue' has a wrong offset!");

// Function Phoenix.ContextualAnimTargetInterface.GetContextualAnimTargetComponent
// 0x0008 (0x0008 - 0x0000)
struct ContextualAnimTargetInterface_GetContextualAnimTargetComponent final
{
public:
	class ULightWeightContextualAnimTargetComponent* ReturnValue;                                    // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ContextualAnimTargetInterface_GetContextualAnimTargetComponent) == 0x000008, "Wrong alignment on ContextualAnimTargetInterface_GetContextualAnimTargetComponent");
static_assert(sizeof(ContextualAnimTargetInterface_GetContextualAnimTargetComponent) == 0x000008, "Wrong size on ContextualAnimTargetInterface_GetContextualAnimTargetComponent");
static_assert(offsetof(ContextualAnimTargetInterface_GetContextualAnimTargetComponent, ReturnValue) == 0x000000, "Member 'ContextualAnimTargetInterface_GetContextualAnimTargetComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.HealthHUD.GetMeterColor
// 0x0010 (0x0010 - 0x0000)
struct HealthHUD_GetMeterColor final
{
public:
	struct FLinearColor                           ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HealthHUD_GetMeterColor) == 0x000004, "Wrong alignment on HealthHUD_GetMeterColor");
static_assert(sizeof(HealthHUD_GetMeterColor) == 0x000010, "Wrong size on HealthHUD_GetMeterColor");
static_assert(offsetof(HealthHUD_GetMeterColor, ReturnValue) == 0x000000, "Member 'HealthHUD_GetMeterColor::ReturnValue' has a wrong offset!");

// Function Phoenix.HealthHUD.GetWidgetLocalCorners
// 0x0018 (0x0018 - 0x0000)
struct HealthHUD_GetWidgetLocalCorners final
{
public:
	class UWidgetComponent*                       WidgetComponent;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FVector>                        ReturnValue;                                       // 0x0008(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(HealthHUD_GetWidgetLocalCorners) == 0x000008, "Wrong alignment on HealthHUD_GetWidgetLocalCorners");
static_assert(sizeof(HealthHUD_GetWidgetLocalCorners) == 0x000018, "Wrong size on HealthHUD_GetWidgetLocalCorners");
static_assert(offsetof(HealthHUD_GetWidgetLocalCorners, WidgetComponent) == 0x000000, "Member 'HealthHUD_GetWidgetLocalCorners::WidgetComponent' has a wrong offset!");
static_assert(offsetof(HealthHUD_GetWidgetLocalCorners, ReturnValue) == 0x000008, "Member 'HealthHUD_GetWidgetLocalCorners::ReturnValue' has a wrong offset!");

// Function Phoenix.HealthHUD.GetWidgetWorldCorners
// 0x0018 (0x0018 - 0x0000)
struct HealthHUD_GetWidgetWorldCorners final
{
public:
	class UWidgetComponent*                       WidgetComponent;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FVector>                        ReturnValue;                                       // 0x0008(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(HealthHUD_GetWidgetWorldCorners) == 0x000008, "Wrong alignment on HealthHUD_GetWidgetWorldCorners");
static_assert(sizeof(HealthHUD_GetWidgetWorldCorners) == 0x000018, "Wrong size on HealthHUD_GetWidgetWorldCorners");
static_assert(offsetof(HealthHUD_GetWidgetWorldCorners, WidgetComponent) == 0x000000, "Member 'HealthHUD_GetWidgetWorldCorners::WidgetComponent' has a wrong offset!");
static_assert(offsetof(HealthHUD_GetWidgetWorldCorners, ReturnValue) == 0x000008, "Member 'HealthHUD_GetWidgetWorldCorners::ReturnValue' has a wrong offset!");

// Function Phoenix.HealthHUD.HandleOnHealthChanged
// 0x0028 (0x0028 - 0x0000)
struct HealthHUD_HandleOnHealthChanged final
{
public:
	class UPhxHealthComponent*                    CallingHealthComp;                                 // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HealthDelta;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HealthHUD_HandleOnHealthChanged) == 0x000008, "Wrong alignment on HealthHUD_HandleOnHealthChanged");
static_assert(sizeof(HealthHUD_HandleOnHealthChanged) == 0x000028, "Wrong size on HealthHUD_HandleOnHealthChanged");
static_assert(offsetof(HealthHUD_HandleOnHealthChanged, CallingHealthComp) == 0x000000, "Member 'HealthHUD_HandleOnHealthChanged::CallingHealthComp' has a wrong offset!");
static_assert(offsetof(HealthHUD_HandleOnHealthChanged, Health) == 0x000008, "Member 'HealthHUD_HandleOnHealthChanged::Health' has a wrong offset!");
static_assert(offsetof(HealthHUD_HandleOnHealthChanged, HealthDelta) == 0x00000C, "Member 'HealthHUD_HandleOnHealthChanged::HealthDelta' has a wrong offset!");
static_assert(offsetof(HealthHUD_HandleOnHealthChanged, DamageType) == 0x000010, "Member 'HealthHUD_HandleOnHealthChanged::DamageType' has a wrong offset!");
static_assert(offsetof(HealthHUD_HandleOnHealthChanged, InstigatedBy) == 0x000018, "Member 'HealthHUD_HandleOnHealthChanged::InstigatedBy' has a wrong offset!");
static_assert(offsetof(HealthHUD_HandleOnHealthChanged, DamageCauser) == 0x000020, "Member 'HealthHUD_HandleOnHealthChanged::DamageCauser' has a wrong offset!");

// Function Phoenix.HealthHUD.OnCriticalSoundEvent
// 0x0010 (0x0010 - 0x0000)
struct HealthHUD_OnCriticalSoundEvent final
{
public:
	EAkCallbackType                               CallbackType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UAkCallbackInfo*                        CallbackInfo;                                      // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HealthHUD_OnCriticalSoundEvent) == 0x000008, "Wrong alignment on HealthHUD_OnCriticalSoundEvent");
static_assert(sizeof(HealthHUD_OnCriticalSoundEvent) == 0x000010, "Wrong size on HealthHUD_OnCriticalSoundEvent");
static_assert(offsetof(HealthHUD_OnCriticalSoundEvent, CallbackType) == 0x000000, "Member 'HealthHUD_OnCriticalSoundEvent::CallbackType' has a wrong offset!");
static_assert(offsetof(HealthHUD_OnCriticalSoundEvent, CallbackInfo) == 0x000008, "Member 'HealthHUD_OnCriticalSoundEvent::CallbackInfo' has a wrong offset!");

// Function Phoenix.HeroInputState.TriggerCuedComboForAttack
// 0x0008 (0x0008 - 0x0000)
struct HeroInputState_TriggerCuedComboForAttack final
{
public:
	class UMeleeAttackState*                      AttackState;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HeroInputState_TriggerCuedComboForAttack) == 0x000008, "Wrong alignment on HeroInputState_TriggerCuedComboForAttack");
static_assert(sizeof(HeroInputState_TriggerCuedComboForAttack) == 0x000008, "Wrong size on HeroInputState_TriggerCuedComboForAttack");
static_assert(offsetof(HeroInputState_TriggerCuedComboForAttack, AttackState) == 0x000000, "Member 'HeroInputState_TriggerCuedComboForAttack::AttackState' has a wrong offset!");

// Function Phoenix.HeroInputState.TriggerCuedComboForDefensiveReact
// 0x0008 (0x0008 - 0x0000)
struct HeroInputState_TriggerCuedComboForDefensiveReact final
{
public:
	class UMontageReactState*                     ReactState;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HeroInputState_TriggerCuedComboForDefensiveReact) == 0x000008, "Wrong alignment on HeroInputState_TriggerCuedComboForDefensiveReact");
static_assert(sizeof(HeroInputState_TriggerCuedComboForDefensiveReact) == 0x000008, "Wrong size on HeroInputState_TriggerCuedComboForDefensiveReact");
static_assert(offsetof(HeroInputState_TriggerCuedComboForDefensiveReact, ReactState) == 0x000000, "Member 'HeroInputState_TriggerCuedComboForDefensiveReact::ReactState' has a wrong offset!");

// Function Phoenix.HeroInputState.TriggerCuedExplicitComboForAttack
// 0x0008 (0x0008 - 0x0000)
struct HeroInputState_TriggerCuedExplicitComboForAttack final
{
public:
	class UMeleeAttackState*                      AttackState;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HeroInputState_TriggerCuedExplicitComboForAttack) == 0x000008, "Wrong alignment on HeroInputState_TriggerCuedExplicitComboForAttack");
static_assert(sizeof(HeroInputState_TriggerCuedExplicitComboForAttack) == 0x000008, "Wrong size on HeroInputState_TriggerCuedExplicitComboForAttack");
static_assert(offsetof(HeroInputState_TriggerCuedExplicitComboForAttack, AttackState) == 0x000000, "Member 'HeroInputState_TriggerCuedExplicitComboForAttack::AttackState' has a wrong offset!");

// Function Phoenix.PhxSkeletalOptimize.EnableOptimize
// 0x0002 (0x0002 - 0x0000)
struct PhxSkeletalOptimize_EnableOptimize final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInit;                                             // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSkeletalOptimize_EnableOptimize) == 0x000001, "Wrong alignment on PhxSkeletalOptimize_EnableOptimize");
static_assert(sizeof(PhxSkeletalOptimize_EnableOptimize) == 0x000002, "Wrong size on PhxSkeletalOptimize_EnableOptimize");
static_assert(offsetof(PhxSkeletalOptimize_EnableOptimize, bEnable) == 0x000000, "Member 'PhxSkeletalOptimize_EnableOptimize::bEnable' has a wrong offset!");
static_assert(offsetof(PhxSkeletalOptimize_EnableOptimize, bInit) == 0x000001, "Member 'PhxSkeletalOptimize_EnableOptimize::bInit' has a wrong offset!");

// Function Phoenix.HitCounter.IsEnabled
// 0x0001 (0x0001 - 0x0000)
struct HitCounter_IsEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HitCounter_IsEnabled) == 0x000001, "Wrong alignment on HitCounter_IsEnabled");
static_assert(sizeof(HitCounter_IsEnabled) == 0x000001, "Wrong size on HitCounter_IsEnabled");
static_assert(offsetof(HitCounter_IsEnabled, ReturnValue) == 0x000000, "Member 'HitCounter_IsEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.HitCounter.PrintStatsToLog
// 0x0010 (0x0010 - 0x0000)
struct HitCounter_PrintStatsToLog final
{
public:
	class UWorld*                                 CurrentWorld;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PlayerIndex;                                       // 0x0008(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(HitCounter_PrintStatsToLog) == 0x000008, "Wrong alignment on HitCounter_PrintStatsToLog");
static_assert(sizeof(HitCounter_PrintStatsToLog) == 0x000010, "Wrong size on HitCounter_PrintStatsToLog");
static_assert(offsetof(HitCounter_PrintStatsToLog, CurrentWorld) == 0x000000, "Member 'HitCounter_PrintStatsToLog::CurrentWorld' has a wrong offset!");
static_assert(offsetof(HitCounter_PrintStatsToLog, PlayerIndex) == 0x000008, "Member 'HitCounter_PrintStatsToLog::PlayerIndex' has a wrong offset!");

// Function Phoenix.HitCounter.ResetStats
// 0x0010 (0x0010 - 0x0000)
struct HitCounter_ResetStats final
{
public:
	class UWorld*                                 CurrentWorld;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PlayerIndex;                                       // 0x0008(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(HitCounter_ResetStats) == 0x000008, "Wrong alignment on HitCounter_ResetStats");
static_assert(sizeof(HitCounter_ResetStats) == 0x000010, "Wrong size on HitCounter_ResetStats");
static_assert(offsetof(HitCounter_ResetStats, CurrentWorld) == 0x000000, "Member 'HitCounter_ResetStats::CurrentWorld' has a wrong offset!");
static_assert(offsetof(HitCounter_ResetStats, PlayerIndex) == 0x000008, "Member 'HitCounter_ResetStats::PlayerIndex' has a wrong offset!");

// Function Phoenix.HitCounter.SetTimerTime
// 0x0004 (0x0004 - 0x0000)
struct HitCounter_SetTimerTime final
{
public:
	float                                         Time;                                              // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HitCounter_SetTimerTime) == 0x000004, "Wrong alignment on HitCounter_SetTimerTime");
static_assert(sizeof(HitCounter_SetTimerTime) == 0x000004, "Wrong size on HitCounter_SetTimerTime");
static_assert(offsetof(HitCounter_SetTimerTime, Time) == 0x000000, "Member 'HitCounter_SetTimerTime::Time' has a wrong offset!");

// Function Phoenix.HitCounter.LogHit
// 0x0018 (0x0018 - 0x0000)
struct HitCounter_LogHit final
{
public:
	class FName                                   BoneHit;                                           // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 GunDebugName;                                      // 0x0008(0x0010)(ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HitCounter_LogHit) == 0x000008, "Wrong alignment on HitCounter_LogHit");
static_assert(sizeof(HitCounter_LogHit) == 0x000018, "Wrong size on HitCounter_LogHit");
static_assert(offsetof(HitCounter_LogHit, BoneHit) == 0x000000, "Member 'HitCounter_LogHit::BoneHit' has a wrong offset!");
static_assert(offsetof(HitCounter_LogHit, GunDebugName) == 0x000008, "Member 'HitCounter_LogHit::GunDebugName' has a wrong offset!");

// Function Phoenix.HitCounter.LogShot
// 0x0010 (0x0010 - 0x0000)
struct HitCounter_LogShot final
{
public:
	class FString                                 GunDebugName;                                      // 0x0000(0x0010)(ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HitCounter_LogShot) == 0x000008, "Wrong alignment on HitCounter_LogShot");
static_assert(sizeof(HitCounter_LogShot) == 0x000010, "Wrong size on HitCounter_LogShot");
static_assert(offsetof(HitCounter_LogShot, GunDebugName) == 0x000000, "Member 'HitCounter_LogShot::GunDebugName' has a wrong offset!");

// Function Phoenix.HitCounter.PrintStatsToScreen
// 0x0004 (0x0004 - 0x0000)
struct HitCounter_PrintStatsToScreen final
{
public:
	float                                         Time;                                              // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HitCounter_PrintStatsToScreen) == 0x000004, "Wrong alignment on HitCounter_PrintStatsToScreen");
static_assert(sizeof(HitCounter_PrintStatsToScreen) == 0x000004, "Wrong size on HitCounter_PrintStatsToScreen");
static_assert(offsetof(HitCounter_PrintStatsToScreen, Time) == 0x000000, "Member 'HitCounter_PrintStatsToScreen::Time' has a wrong offset!");

// Function Phoenix.HitCounter.SetWorld
// 0x0008 (0x0008 - 0x0000)
struct HitCounter_SetWorld final
{
public:
	class UWorld*                                 NewWorld;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HitCounter_SetWorld) == 0x000008, "Wrong alignment on HitCounter_SetWorld");
static_assert(sizeof(HitCounter_SetWorld) == 0x000008, "Wrong size on HitCounter_SetWorld");
static_assert(offsetof(HitCounter_SetWorld, NewWorld) == 0x000000, "Member 'HitCounter_SetWorld::NewWorld' has a wrong offset!");

// Function Phoenix.HologramPrintingMesh.GetPrinterSkeletalMeshComp
// 0x0008 (0x0008 - 0x0000)
struct HologramPrintingMesh_GetPrinterSkeletalMeshComp final
{
public:
	class USkeletalMeshComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HologramPrintingMesh_GetPrinterSkeletalMeshComp) == 0x000008, "Wrong alignment on HologramPrintingMesh_GetPrinterSkeletalMeshComp");
static_assert(sizeof(HologramPrintingMesh_GetPrinterSkeletalMeshComp) == 0x000008, "Wrong size on HologramPrintingMesh_GetPrinterSkeletalMeshComp");
static_assert(offsetof(HologramPrintingMesh_GetPrinterSkeletalMeshComp, ReturnValue) == 0x000000, "Member 'HologramPrintingMesh_GetPrinterSkeletalMeshComp::ReturnValue' has a wrong offset!");

// Function Phoenix.HologramPrintingMesh.SetHologramMesh
// 0x0040 (0x0040 - 0x0000)
struct HologramPrintingMesh_SetHologramMesh final
{
public:
	class USkeletalMesh*                          NewHologramSkeletalMesh;                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UStaticMesh*                            NewHologramStaticMesh;                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FTransform                             NewTransform;                                      // 0x0010(0x0030)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(HologramPrintingMesh_SetHologramMesh) == 0x000010, "Wrong alignment on HologramPrintingMesh_SetHologramMesh");
static_assert(sizeof(HologramPrintingMesh_SetHologramMesh) == 0x000040, "Wrong size on HologramPrintingMesh_SetHologramMesh");
static_assert(offsetof(HologramPrintingMesh_SetHologramMesh, NewHologramSkeletalMesh) == 0x000000, "Member 'HologramPrintingMesh_SetHologramMesh::NewHologramSkeletalMesh' has a wrong offset!");
static_assert(offsetof(HologramPrintingMesh_SetHologramMesh, NewHologramStaticMesh) == 0x000008, "Member 'HologramPrintingMesh_SetHologramMesh::NewHologramStaticMesh' has a wrong offset!");
static_assert(offsetof(HologramPrintingMesh_SetHologramMesh, NewTransform) == 0x000010, "Member 'HologramPrintingMesh_SetHologramMesh::NewTransform' has a wrong offset!");

// Function Phoenix.HologramPrintingMesh.SetPrinterSkeletalMeshComp
// 0x0008 (0x0008 - 0x0000)
struct HologramPrintingMesh_SetPrinterSkeletalMeshComp final
{
public:
	class USkeletalMeshComponent*                 NewSkeletalMesh;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(HologramPrintingMesh_SetPrinterSkeletalMeshComp) == 0x000008, "Wrong alignment on HologramPrintingMesh_SetPrinterSkeletalMeshComp");
static_assert(sizeof(HologramPrintingMesh_SetPrinterSkeletalMeshComp) == 0x000008, "Wrong size on HologramPrintingMesh_SetPrinterSkeletalMeshComp");
static_assert(offsetof(HologramPrintingMesh_SetPrinterSkeletalMeshComp, NewSkeletalMesh) == 0x000000, "Member 'HologramPrintingMesh_SetPrinterSkeletalMeshComp::NewSkeletalMesh' has a wrong offset!");

// Function Phoenix.PhxMovementSplineObstacleInterface.OnMovementSplineSubjectHitObstacle
// 0x0098 (0x0098 - 0x0000)
struct PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle final
{
public:
	struct FHitResult                             HitResult;                                         // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	class AActor*                                 MovementActor;                                     // 0x0088(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxMovementSpline*                     MovementSpline;                                    // 0x0090(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle) == 0x000008, "Wrong alignment on PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle");
static_assert(sizeof(PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle) == 0x000098, "Wrong size on PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle");
static_assert(offsetof(PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle, HitResult) == 0x000000, "Member 'PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle::HitResult' has a wrong offset!");
static_assert(offsetof(PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle, MovementActor) == 0x000088, "Member 'PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle::MovementActor' has a wrong offset!");
static_assert(offsetof(PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle, MovementSpline) == 0x000090, "Member 'PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle::MovementSpline' has a wrong offset!");

// Function Phoenix.InteractablePickupComponent.GetEquippableClass
// 0x0008 (0x0008 - 0x0000)
struct InteractablePickupComponent_GetEquippableClass final
{
public:
	TSubclassOf<class AEquippable>                ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractablePickupComponent_GetEquippableClass) == 0x000008, "Wrong alignment on InteractablePickupComponent_GetEquippableClass");
static_assert(sizeof(InteractablePickupComponent_GetEquippableClass) == 0x000008, "Wrong size on InteractablePickupComponent_GetEquippableClass");
static_assert(offsetof(InteractablePickupComponent_GetEquippableClass, ReturnValue) == 0x000000, "Member 'InteractablePickupComponent_GetEquippableClass::ReturnValue' has a wrong offset!");

// Function Phoenix.InteractablePickupComponent.SetEquippableClass
// 0x0008 (0x0008 - 0x0000)
struct InteractablePickupComponent_SetEquippableClass final
{
public:
	TSubclassOf<class AEquippable>                NewEquippableClass;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractablePickupComponent_SetEquippableClass) == 0x000008, "Wrong alignment on InteractablePickupComponent_SetEquippableClass");
static_assert(sizeof(InteractablePickupComponent_SetEquippableClass) == 0x000008, "Wrong size on InteractablePickupComponent_SetEquippableClass");
static_assert(offsetof(InteractablePickupComponent_SetEquippableClass, NewEquippableClass) == 0x000000, "Member 'InteractablePickupComponent_SetEquippableClass::NewEquippableClass' has a wrong offset!");

// Function Phoenix.InteractablePickupComponent.ShouldDestroyPickupActor
// 0x0001 (0x0001 - 0x0000)
struct InteractablePickupComponent_ShouldDestroyPickupActor final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractablePickupComponent_ShouldDestroyPickupActor) == 0x000001, "Wrong alignment on InteractablePickupComponent_ShouldDestroyPickupActor");
static_assert(sizeof(InteractablePickupComponent_ShouldDestroyPickupActor) == 0x000001, "Wrong size on InteractablePickupComponent_ShouldDestroyPickupActor");
static_assert(offsetof(InteractablePickupComponent_ShouldDestroyPickupActor, ReturnValue) == 0x000000, "Member 'InteractablePickupComponent_ShouldDestroyPickupActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxTexMemUsageManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxTexMemUsageManager_Get final
{
public:
	const class UObject*                          WorldContext;                                      // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxTexMemUsageManager*                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTexMemUsageManager_Get) == 0x000008, "Wrong alignment on PhxTexMemUsageManager_Get");
static_assert(sizeof(PhxTexMemUsageManager_Get) == 0x000010, "Wrong size on PhxTexMemUsageManager_Get");
static_assert(offsetof(PhxTexMemUsageManager_Get, WorldContext) == 0x000000, "Member 'PhxTexMemUsageManager_Get::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxTexMemUsageManager_Get, ReturnValue) == 0x000008, "Member 'PhxTexMemUsageManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSnowcatSpline.StartSnowcatDrive
// 0x0008 (0x0008 - 0x0000)
struct PhxSnowcatSpline_StartSnowcatDrive final
{
public:
	class APhxSnowcat*                            InSnowcat;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSnowcatSpline_StartSnowcatDrive) == 0x000008, "Wrong alignment on PhxSnowcatSpline_StartSnowcatDrive");
static_assert(sizeof(PhxSnowcatSpline_StartSnowcatDrive) == 0x000008, "Wrong size on PhxSnowcatSpline_StartSnowcatDrive");
static_assert(offsetof(PhxSnowcatSpline_StartSnowcatDrive, InSnowcat) == 0x000000, "Member 'PhxSnowcatSpline_StartSnowcatDrive::InSnowcat' has a wrong offset!");

// Function Phoenix.InteractionWidget.SetIcon
// 0x0008 (0x0008 - 0x0000)
struct InteractionWidget_SetIcon final
{
public:
	class UTexture*                               NewInputIconTexture;                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractionWidget_SetIcon) == 0x000008, "Wrong alignment on InteractionWidget_SetIcon");
static_assert(sizeof(InteractionWidget_SetIcon) == 0x000008, "Wrong size on InteractionWidget_SetIcon");
static_assert(offsetof(InteractionWidget_SetIcon, NewInputIconTexture) == 0x000000, "Member 'InteractionWidget_SetIcon::NewInputIconTexture' has a wrong offset!");

// Function Phoenix.InteractionWidget.SetProgress
// 0x0004 (0x0004 - 0x0000)
struct InteractionWidget_SetProgress final
{
public:
	float                                         ProgressPercentage;                                // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InteractionWidget_SetProgress) == 0x000004, "Wrong alignment on InteractionWidget_SetProgress");
static_assert(sizeof(InteractionWidget_SetProgress) == 0x000004, "Wrong size on InteractionWidget_SetProgress");
static_assert(offsetof(InteractionWidget_SetProgress, ProgressPercentage) == 0x000000, "Member 'InteractionWidget_SetProgress::ProgressPercentage' has a wrong offset!");

// Function Phoenix.InventoryArsenalPanel.IsSwappableSlot
// 0x0010 (0x0010 - 0x0000)
struct InventoryArsenalPanel_IsSwappableSlot final
{
public:
	const class UArsenalSlot*                     InSlot;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryArsenalPanel_IsSwappableSlot) == 0x000008, "Wrong alignment on InventoryArsenalPanel_IsSwappableSlot");
static_assert(sizeof(InventoryArsenalPanel_IsSwappableSlot) == 0x000010, "Wrong size on InventoryArsenalPanel_IsSwappableSlot");
static_assert(offsetof(InventoryArsenalPanel_IsSwappableSlot, InSlot) == 0x000000, "Member 'InventoryArsenalPanel_IsSwappableSlot::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryArsenalPanel_IsSwappableSlot, ReturnValue) == 0x000008, "Member 'InventoryArsenalPanel_IsSwappableSlot::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryBioDetails.GetSelected
// 0x0008 (0x0008 - 0x0000)
struct InventoryBioDetails_GetSelected final
{
public:
	class UPhxSelectable*                         ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryBioDetails_GetSelected) == 0x000008, "Wrong alignment on InventoryBioDetails_GetSelected");
static_assert(sizeof(InventoryBioDetails_GetSelected) == 0x000008, "Wrong size on InventoryBioDetails_GetSelected");
static_assert(offsetof(InventoryBioDetails_GetSelected, ReturnValue) == 0x000000, "Member 'InventoryBioDetails_GetSelected::ReturnValue' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandleActionDenied
// 0x0100 (0x0100 - 0x0000)
struct InventoryFrame_HandleActionDenied final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryFrame_HandleActionDenied) == 0x000008, "Wrong alignment on InventoryFrame_HandleActionDenied");
static_assert(sizeof(InventoryFrame_HandleActionDenied) == 0x000100, "Wrong size on InventoryFrame_HandleActionDenied");
static_assert(offsetof(InventoryFrame_HandleActionDenied, ItemData) == 0x000000, "Member 'InventoryFrame_HandleActionDenied::ItemData' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandleActivePanelOnEdge
// 0x0010 (0x0010 - 0x0000)
struct InventoryFrame_HandleActivePanelOnEdge final
{
public:
	class UInventorySlot*                         InSlot;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryFrame_HandleActivePanelOnEdge) == 0x000008, "Wrong alignment on InventoryFrame_HandleActivePanelOnEdge");
static_assert(sizeof(InventoryFrame_HandleActivePanelOnEdge) == 0x000010, "Wrong size on InventoryFrame_HandleActivePanelOnEdge");
static_assert(offsetof(InventoryFrame_HandleActivePanelOnEdge, InSlot) == 0x000000, "Member 'InventoryFrame_HandleActivePanelOnEdge::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryFrame_HandleActivePanelOnEdge, Direction) == 0x000008, "Member 'InventoryFrame_HandleActivePanelOnEdge::Direction' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandleDetailsFocused
// 0x0001 (0x0001 - 0x0000)
struct InventoryFrame_HandleDetailsFocused final
{
public:
	bool                                          bFocused;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryFrame_HandleDetailsFocused) == 0x000001, "Wrong alignment on InventoryFrame_HandleDetailsFocused");
static_assert(sizeof(InventoryFrame_HandleDetailsFocused) == 0x000001, "Wrong size on InventoryFrame_HandleDetailsFocused");
static_assert(offsetof(InventoryFrame_HandleDetailsFocused, bFocused) == 0x000000, "Member 'InventoryFrame_HandleDetailsFocused::bFocused' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandleFaceBottomHold
// 0x0010 (0x0010 - 0x0000)
struct InventoryFrame_HandleFaceBottomHold final
{
public:
	class UInventorySlot*                         InSlot;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Amount;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryFrame_HandleFaceBottomHold) == 0x000008, "Wrong alignment on InventoryFrame_HandleFaceBottomHold");
static_assert(sizeof(InventoryFrame_HandleFaceBottomHold) == 0x000010, "Wrong size on InventoryFrame_HandleFaceBottomHold");
static_assert(offsetof(InventoryFrame_HandleFaceBottomHold, InSlot) == 0x000000, "Member 'InventoryFrame_HandleFaceBottomHold::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryFrame_HandleFaceBottomHold, Amount) == 0x000008, "Member 'InventoryFrame_HandleFaceBottomHold::Amount' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandleFaceTopHold
// 0x0010 (0x0010 - 0x0000)
struct InventoryFrame_HandleFaceTopHold final
{
public:
	class UInventorySlot*                         InSlot;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Amount;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryFrame_HandleFaceTopHold) == 0x000008, "Wrong alignment on InventoryFrame_HandleFaceTopHold");
static_assert(sizeof(InventoryFrame_HandleFaceTopHold) == 0x000010, "Wrong size on InventoryFrame_HandleFaceTopHold");
static_assert(offsetof(InventoryFrame_HandleFaceTopHold, InSlot) == 0x000000, "Member 'InventoryFrame_HandleFaceTopHold::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryFrame_HandleFaceTopHold, Amount) == 0x000008, "Member 'InventoryFrame_HandleFaceTopHold::Amount' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandleItemConsumed
// 0x0100 (0x0100 - 0x0000)
struct InventoryFrame_HandleItemConsumed final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryFrame_HandleItemConsumed) == 0x000008, "Wrong alignment on InventoryFrame_HandleItemConsumed");
static_assert(sizeof(InventoryFrame_HandleItemConsumed) == 0x000100, "Wrong size on InventoryFrame_HandleItemConsumed");
static_assert(offsetof(InventoryFrame_HandleItemConsumed, ItemData) == 0x000000, "Member 'InventoryFrame_HandleItemConsumed::ItemData' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandleItemDropped
// 0x0100 (0x0100 - 0x0000)
struct InventoryFrame_HandleItemDropped final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryFrame_HandleItemDropped) == 0x000008, "Wrong alignment on InventoryFrame_HandleItemDropped");
static_assert(sizeof(InventoryFrame_HandleItemDropped) == 0x000100, "Wrong size on InventoryFrame_HandleItemDropped");
static_assert(offsetof(InventoryFrame_HandleItemDropped, InItem) == 0x000000, "Member 'InventoryFrame_HandleItemDropped::InItem' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandlePanelNavigation
// 0x0010 (0x0010 - 0x0000)
struct InventoryFrame_HandlePanelNavigation final
{
public:
	class UInventorySlot*                         InSlot;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(InventoryFrame_HandlePanelNavigation) == 0x000008, "Wrong alignment on InventoryFrame_HandlePanelNavigation");
static_assert(sizeof(InventoryFrame_HandlePanelNavigation) == 0x000010, "Wrong size on InventoryFrame_HandlePanelNavigation");
static_assert(offsetof(InventoryFrame_HandlePanelNavigation, InSlot) == 0x000000, "Member 'InventoryFrame_HandlePanelNavigation::InSlot' has a wrong offset!");
static_assert(offsetof(InventoryFrame_HandlePanelNavigation, Direction) == 0x000008, "Member 'InventoryFrame_HandlePanelNavigation::Direction' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandleTabChanged
// 0x0004 (0x0004 - 0x0000)
struct InventoryFrame_HandleTabChanged final
{
public:
	int32                                         Index_0;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryFrame_HandleTabChanged) == 0x000004, "Wrong alignment on InventoryFrame_HandleTabChanged");
static_assert(sizeof(InventoryFrame_HandleTabChanged) == 0x000004, "Wrong size on InventoryFrame_HandleTabChanged");
static_assert(offsetof(InventoryFrame_HandleTabChanged, Index_0) == 0x000000, "Member 'InventoryFrame_HandleTabChanged::Index_0' has a wrong offset!");

// Function Phoenix.InventoryFrame.HandleViewItem
// 0x0100 (0x0100 - 0x0000)
struct InventoryFrame_HandleViewItem final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryFrame_HandleViewItem) == 0x000008, "Wrong alignment on InventoryFrame_HandleViewItem");
static_assert(sizeof(InventoryFrame_HandleViewItem) == 0x000100, "Wrong size on InventoryFrame_HandleViewItem");
static_assert(offsetof(InventoryFrame_HandleViewItem, InItem) == 0x000000, "Member 'InventoryFrame_HandleViewItem::InItem' has a wrong offset!");

// Function Phoenix.InventoryFrame.OnInventoryChanged
// 0x000C (0x000C - 0x0000)
struct InventoryFrame_OnInventoryChanged final
{
public:
	class FName                                   ItemModified;                                      // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Quantity;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryFrame_OnInventoryChanged) == 0x000004, "Wrong alignment on InventoryFrame_OnInventoryChanged");
static_assert(sizeof(InventoryFrame_OnInventoryChanged) == 0x00000C, "Wrong size on InventoryFrame_OnInventoryChanged");
static_assert(offsetof(InventoryFrame_OnInventoryChanged, ItemModified) == 0x000000, "Member 'InventoryFrame_OnInventoryChanged::ItemModified' has a wrong offset!");
static_assert(offsetof(InventoryFrame_OnInventoryChanged, Quantity) == 0x000008, "Member 'InventoryFrame_OnInventoryChanged::Quantity' has a wrong offset!");

// Function Phoenix.InventoryFrame.GetActivePanel
// 0x0008 (0x0008 - 0x0000)
struct InventoryFrame_GetActivePanel final
{
public:
	class UInventoryPanel*                        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InventoryFrame_GetActivePanel) == 0x000008, "Wrong alignment on InventoryFrame_GetActivePanel");
static_assert(sizeof(InventoryFrame_GetActivePanel) == 0x000008, "Wrong size on InventoryFrame_GetActivePanel");
static_assert(offsetof(InventoryFrame_GetActivePanel, ReturnValue) == 0x000000, "Member 'InventoryFrame_GetActivePanel::ReturnValue' has a wrong offset!");

// Function Phoenix.AmmoSlot.GetNumStacks
// 0x0004 (0x0004 - 0x0000)
struct AmmoSlot_GetNumStacks final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AmmoSlot_GetNumStacks) == 0x000004, "Wrong alignment on AmmoSlot_GetNumStacks");
static_assert(sizeof(AmmoSlot_GetNumStacks) == 0x000004, "Wrong size on AmmoSlot_GetNumStacks");
static_assert(offsetof(AmmoSlot_GetNumStacks, ReturnValue) == 0x000000, "Member 'AmmoSlot_GetNumStacks::ReturnValue' has a wrong offset!");

// Function Phoenix.ItemAmmoBox.GetAmmoAmount
// 0x0004 (0x0004 - 0x0000)
struct ItemAmmoBox_GetAmmoAmount final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ItemAmmoBox_GetAmmoAmount) == 0x000004, "Wrong alignment on ItemAmmoBox_GetAmmoAmount");
static_assert(sizeof(ItemAmmoBox_GetAmmoAmount) == 0x000004, "Wrong size on ItemAmmoBox_GetAmmoAmount");
static_assert(offsetof(ItemAmmoBox_GetAmmoAmount, ReturnValue) == 0x000000, "Member 'ItemAmmoBox_GetAmmoAmount::ReturnValue' has a wrong offset!");

// Function Phoenix.ItemAmmoBox.GetAmmoWeaponType
// 0x0008 (0x0008 - 0x0000)
struct ItemAmmoBox_GetAmmoWeaponType final
{
public:
	TSubclassOf<class APhxRangedWeapon>           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ItemAmmoBox_GetAmmoWeaponType) == 0x000008, "Wrong alignment on ItemAmmoBox_GetAmmoWeaponType");
static_assert(sizeof(ItemAmmoBox_GetAmmoWeaponType) == 0x000008, "Wrong size on ItemAmmoBox_GetAmmoWeaponType");
static_assert(offsetof(ItemAmmoBox_GetAmmoWeaponType, ReturnValue) == 0x000000, "Member 'ItemAmmoBox_GetAmmoWeaponType::ReturnValue' has a wrong offset!");

// Function Phoenix.Keypad.CompareInputWithPassword
// 0x0001 (0x0001 - 0x0000)
struct Keypad_CompareInputWithPassword final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Keypad_CompareInputWithPassword) == 0x000001, "Wrong alignment on Keypad_CompareInputWithPassword");
static_assert(sizeof(Keypad_CompareInputWithPassword) == 0x000001, "Wrong size on Keypad_CompareInputWithPassword");
static_assert(offsetof(Keypad_CompareInputWithPassword, ReturnValue) == 0x000000, "Member 'Keypad_CompareInputWithPassword::ReturnValue' has a wrong offset!");

// Function Phoenix.Keypad.MoveKeyIndex
// 0x0004 (0x0004 - 0x0000)
struct Keypad_MoveKeyIndex final
{
public:
	int32                                         Spaces;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Keypad_MoveKeyIndex) == 0x000004, "Wrong alignment on Keypad_MoveKeyIndex");
static_assert(sizeof(Keypad_MoveKeyIndex) == 0x000004, "Wrong size on Keypad_MoveKeyIndex");
static_assert(offsetof(Keypad_MoveKeyIndex, Spaces) == 0x000000, "Member 'Keypad_MoveKeyIndex::Spaces' has a wrong offset!");

// Function Phoenix.Keypad.OnPlayerInteract
// 0x0008 (0x0008 - 0x0000)
struct Keypad_OnPlayerInteract final
{
public:
	class APhxCharacter*                          InteractingCharacter;                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Keypad_OnPlayerInteract) == 0x000008, "Wrong alignment on Keypad_OnPlayerInteract");
static_assert(sizeof(Keypad_OnPlayerInteract) == 0x000008, "Wrong size on Keypad_OnPlayerInteract");
static_assert(offsetof(Keypad_OnPlayerInteract, InteractingCharacter) == 0x000000, "Member 'Keypad_OnPlayerInteract::InteractingCharacter' has a wrong offset!");

// Function Phoenix.Keypad.GetCancelPressed
// 0x0001 (0x0001 - 0x0000)
struct Keypad_GetCancelPressed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Keypad_GetCancelPressed) == 0x000001, "Wrong alignment on Keypad_GetCancelPressed");
static_assert(sizeof(Keypad_GetCancelPressed) == 0x000001, "Wrong size on Keypad_GetCancelPressed");
static_assert(offsetof(Keypad_GetCancelPressed, ReturnValue) == 0x000000, "Member 'Keypad_GetCancelPressed::ReturnValue' has a wrong offset!");

// Function Phoenix.Keypad.GetConfirmPressed
// 0x0001 (0x0001 - 0x0000)
struct Keypad_GetConfirmPressed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Keypad_GetConfirmPressed) == 0x000001, "Wrong alignment on Keypad_GetConfirmPressed");
static_assert(sizeof(Keypad_GetConfirmPressed) == 0x000001, "Wrong size on Keypad_GetConfirmPressed");
static_assert(offsetof(Keypad_GetConfirmPressed, ReturnValue) == 0x000000, "Member 'Keypad_GetConfirmPressed::ReturnValue' has a wrong offset!");

// Function Phoenix.Keypad.GetCurrentKeyIndex
// 0x0004 (0x0004 - 0x0000)
struct Keypad_GetCurrentKeyIndex final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Keypad_GetCurrentKeyIndex) == 0x000004, "Wrong alignment on Keypad_GetCurrentKeyIndex");
static_assert(sizeof(Keypad_GetCurrentKeyIndex) == 0x000004, "Wrong size on Keypad_GetCurrentKeyIndex");
static_assert(offsetof(Keypad_GetCurrentKeyIndex, ReturnValue) == 0x000000, "Member 'Keypad_GetCurrentKeyIndex::ReturnValue' has a wrong offset!");

// Function Phoenix.Keypad.GetLeftPressed
// 0x0001 (0x0001 - 0x0000)
struct Keypad_GetLeftPressed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Keypad_GetLeftPressed) == 0x000001, "Wrong alignment on Keypad_GetLeftPressed");
static_assert(sizeof(Keypad_GetLeftPressed) == 0x000001, "Wrong size on Keypad_GetLeftPressed");
static_assert(offsetof(Keypad_GetLeftPressed, ReturnValue) == 0x000000, "Member 'Keypad_GetLeftPressed::ReturnValue' has a wrong offset!");

// Function Phoenix.Keypad.GetRightPressed
// 0x0001 (0x0001 - 0x0000)
struct Keypad_GetRightPressed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Keypad_GetRightPressed) == 0x000001, "Wrong alignment on Keypad_GetRightPressed");
static_assert(sizeof(Keypad_GetRightPressed) == 0x000001, "Wrong size on Keypad_GetRightPressed");
static_assert(offsetof(Keypad_GetRightPressed, ReturnValue) == 0x000000, "Member 'Keypad_GetRightPressed::ReturnValue' has a wrong offset!");

// Function Phoenix.Keypad.ShouldCheckInput
// 0x0001 (0x0001 - 0x0000)
struct Keypad_ShouldCheckInput final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Keypad_ShouldCheckInput) == 0x000001, "Wrong alignment on Keypad_ShouldCheckInput");
static_assert(sizeof(Keypad_ShouldCheckInput) == 0x000001, "Wrong size on Keypad_ShouldCheckInput");
static_assert(offsetof(Keypad_ShouldCheckInput, ReturnValue) == 0x000000, "Member 'Keypad_ShouldCheckInput::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_UsePointOfInterest.UsePointOfInterest
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIPointOfInterest*                  PointOfInterest;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_UsePointOfInterest* ReturnValue;                                     // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest");
static_assert(sizeof(PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest) == 0x000018, "Wrong size on PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest");
static_assert(offsetof(PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest, Character) == 0x000000, "Member 'PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest, PointOfInterest) == 0x000008, "Member 'PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest::PointOfInterest' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest, ReturnValue) == 0x000010, "Member 'PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_UsePointOfInterest.HandlePointOfInterestDeparted
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted final
{
public:
	class APhxAICharacter*                        Occupier;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIPointOfInterest*                  PointOfInterest;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInterrupted;                                      // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted");
static_assert(sizeof(PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted) == 0x000018, "Wrong size on PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted");
static_assert(offsetof(PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted, Occupier) == 0x000000, "Member 'PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted::Occupier' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted, PointOfInterest) == 0x000008, "Member 'PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted::PointOfInterest' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted, bInterrupted) == 0x000010, "Member 'PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted::bInterrupted' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_UsePointOfInterest.HandlePointOfInterestReached
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached final
{
public:
	class APhxAICharacter*                        Occupier;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIPointOfInterest*                  PointOfInterest;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached");
static_assert(sizeof(PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached) == 0x000010, "Wrong size on PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached");
static_assert(offsetof(PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached, Occupier) == 0x000000, "Member 'PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached::Occupier' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached, PointOfInterest) == 0x000008, "Member 'PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached::PointOfInterest' has a wrong offset!");

// Function Phoenix.LevelSelectWidget.GetFirstButton
// 0x0008 (0x0008 - 0x0000)
struct LevelSelectWidget_GetFirstButton final
{
public:
	class UMenuButton*                            ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(LevelSelectWidget_GetFirstButton) == 0x000008, "Wrong alignment on LevelSelectWidget_GetFirstButton");
static_assert(sizeof(LevelSelectWidget_GetFirstButton) == 0x000008, "Wrong size on LevelSelectWidget_GetFirstButton");
static_assert(offsetof(LevelSelectWidget_GetFirstButton, ReturnValue) == 0x000000, "Member 'LevelSelectWidget_GetFirstButton::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterBase.PlayDialogue
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterBase_PlayDialogue final
{
public:
	class UDialogue*                              InDialogue;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterBase_PlayDialogue) == 0x000008, "Wrong alignment on PhxCharacterBase_PlayDialogue");
static_assert(sizeof(PhxCharacterBase_PlayDialogue) == 0x000008, "Wrong size on PhxCharacterBase_PlayDialogue");
static_assert(offsetof(PhxCharacterBase_PlayDialogue, InDialogue) == 0x000000, "Member 'PhxCharacterBase_PlayDialogue::InDialogue' has a wrong offset!");

// Function Phoenix.PhxCharacterBase.StartRagdoll
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterBase_StartRagdoll final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterBase_StartRagdoll) == 0x000001, "Wrong alignment on PhxCharacterBase_StartRagdoll");
static_assert(sizeof(PhxCharacterBase_StartRagdoll) == 0x000001, "Wrong size on PhxCharacterBase_StartRagdoll");
static_assert(offsetof(PhxCharacterBase_StartRagdoll, ReturnValue) == 0x000000, "Member 'PhxCharacterBase_StartRagdoll::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterBase.StopRagdoll
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterBase_StopRagdoll final
{
public:
	bool                                          bReenableMovement;                                 // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterBase_StopRagdoll) == 0x000001, "Wrong alignment on PhxCharacterBase_StopRagdoll");
static_assert(sizeof(PhxCharacterBase_StopRagdoll) == 0x000001, "Wrong size on PhxCharacterBase_StopRagdoll");
static_assert(offsetof(PhxCharacterBase_StopRagdoll, bReenableMovement) == 0x000000, "Member 'PhxCharacterBase_StopRagdoll::bReenableMovement' has a wrong offset!");

// Function Phoenix.PhxCharacter.ClearPoseSnapshot
// 0x0004 (0x0004 - 0x0000)
struct PhxCharacter_ClearPoseSnapshot final
{
public:
	float                                         BlendOutTime;                                      // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_ClearPoseSnapshot) == 0x000004, "Wrong alignment on PhxCharacter_ClearPoseSnapshot");
static_assert(sizeof(PhxCharacter_ClearPoseSnapshot) == 0x000004, "Wrong size on PhxCharacter_ClearPoseSnapshot");
static_assert(offsetof(PhxCharacter_ClearPoseSnapshot, BlendOutTime) == 0x000000, "Member 'PhxCharacter_ClearPoseSnapshot::BlendOutTime' has a wrong offset!");

// Function Phoenix.PhxCharacter.EndPhysics
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacter_EndPhysics final
{
public:
	class FName                                   BodyName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ProfileName;                                       // 0x0008(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIncludeSelf;                                      // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x3];                                       // 0x0011(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         BlendOutTime;                                      // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_EndPhysics) == 0x000004, "Wrong alignment on PhxCharacter_EndPhysics");
static_assert(sizeof(PhxCharacter_EndPhysics) == 0x000018, "Wrong size on PhxCharacter_EndPhysics");
static_assert(offsetof(PhxCharacter_EndPhysics, BodyName) == 0x000000, "Member 'PhxCharacter_EndPhysics::BodyName' has a wrong offset!");
static_assert(offsetof(PhxCharacter_EndPhysics, ProfileName) == 0x000008, "Member 'PhxCharacter_EndPhysics::ProfileName' has a wrong offset!");
static_assert(offsetof(PhxCharacter_EndPhysics, bIncludeSelf) == 0x000010, "Member 'PhxCharacter_EndPhysics::bIncludeSelf' has a wrong offset!");
static_assert(offsetof(PhxCharacter_EndPhysics, BlendOutTime) == 0x000014, "Member 'PhxCharacter_EndPhysics::BlendOutTime' has a wrong offset!");

// Function Phoenix.PhxCharacter.EnterTaggedTriggerVolume
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_EnterTaggedTriggerVolume final
{
public:
	class AActor*                                 TriggerActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_EnterTaggedTriggerVolume) == 0x000008, "Wrong alignment on PhxCharacter_EnterTaggedTriggerVolume");
static_assert(sizeof(PhxCharacter_EnterTaggedTriggerVolume) == 0x000008, "Wrong size on PhxCharacter_EnterTaggedTriggerVolume");
static_assert(offsetof(PhxCharacter_EnterTaggedTriggerVolume, TriggerActor) == 0x000000, "Member 'PhxCharacter_EnterTaggedTriggerVolume::TriggerActor' has a wrong offset!");

// Function Phoenix.PhxCharacter.ExitTaggedTriggerVolume
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_ExitTaggedTriggerVolume final
{
public:
	class AActor*                                 TriggerActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_ExitTaggedTriggerVolume) == 0x000008, "Wrong alignment on PhxCharacter_ExitTaggedTriggerVolume");
static_assert(sizeof(PhxCharacter_ExitTaggedTriggerVolume) == 0x000008, "Wrong size on PhxCharacter_ExitTaggedTriggerVolume");
static_assert(offsetof(PhxCharacter_ExitTaggedTriggerVolume, TriggerActor) == 0x000000, "Member 'PhxCharacter_ExitTaggedTriggerVolume::TriggerActor' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetAllEquipment
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacter_GetAllEquipment final
{
public:
	TArray<class AEquippable*>                    ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetAllEquipment) == 0x000008, "Wrong alignment on PhxCharacter_GetAllEquipment");
static_assert(sizeof(PhxCharacter_GetAllEquipment) == 0x000010, "Wrong size on PhxCharacter_GetAllEquipment");
static_assert(offsetof(PhxCharacter_GetAllEquipment, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetAllEquipment::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.HandleOnHealthChanged
// 0x0028 (0x0028 - 0x0000)
struct PhxCharacter_HandleOnHealthChanged final
{
public:
	class UPhxHealthComponent*                    CallingHealthComp;                                 // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HealthDelta;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_HandleOnHealthChanged) == 0x000008, "Wrong alignment on PhxCharacter_HandleOnHealthChanged");
static_assert(sizeof(PhxCharacter_HandleOnHealthChanged) == 0x000028, "Wrong size on PhxCharacter_HandleOnHealthChanged");
static_assert(offsetof(PhxCharacter_HandleOnHealthChanged, CallingHealthComp) == 0x000000, "Member 'PhxCharacter_HandleOnHealthChanged::CallingHealthComp' has a wrong offset!");
static_assert(offsetof(PhxCharacter_HandleOnHealthChanged, Health) == 0x000008, "Member 'PhxCharacter_HandleOnHealthChanged::Health' has a wrong offset!");
static_assert(offsetof(PhxCharacter_HandleOnHealthChanged, HealthDelta) == 0x00000C, "Member 'PhxCharacter_HandleOnHealthChanged::HealthDelta' has a wrong offset!");
static_assert(offsetof(PhxCharacter_HandleOnHealthChanged, DamageType) == 0x000010, "Member 'PhxCharacter_HandleOnHealthChanged::DamageType' has a wrong offset!");
static_assert(offsetof(PhxCharacter_HandleOnHealthChanged, InstigatedBy) == 0x000018, "Member 'PhxCharacter_HandleOnHealthChanged::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxCharacter_HandleOnHealthChanged, DamageCauser) == 0x000020, "Member 'PhxCharacter_HandleOnHealthChanged::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsOnCamera
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_IsOnCamera final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_IsOnCamera) == 0x000001, "Wrong alignment on PhxCharacter_IsOnCamera");
static_assert(sizeof(PhxCharacter_IsOnCamera) == 0x000001, "Wrong size on PhxCharacter_IsOnCamera");
static_assert(offsetof(PhxCharacter_IsOnCamera, ReturnValue) == 0x000000, "Member 'PhxCharacter_IsOnCamera::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsPhysicsActive
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_IsPhysicsActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_IsPhysicsActive) == 0x000001, "Wrong alignment on PhxCharacter_IsPhysicsActive");
static_assert(sizeof(PhxCharacter_IsPhysicsActive) == 0x000001, "Wrong size on PhxCharacter_IsPhysicsActive");
static_assert(offsetof(PhxCharacter_IsPhysicsActive, ReturnValue) == 0x000000, "Member 'PhxCharacter_IsPhysicsActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.Kill
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacter_Kill final
{
public:
	class AActor*                                 DamageCauser;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UDamageType>                DamageType;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_Kill) == 0x000008, "Wrong alignment on PhxCharacter_Kill");
static_assert(sizeof(PhxCharacter_Kill) == 0x000010, "Wrong size on PhxCharacter_Kill");
static_assert(offsetof(PhxCharacter_Kill, DamageCauser) == 0x000000, "Member 'PhxCharacter_Kill::DamageCauser' has a wrong offset!");
static_assert(offsetof(PhxCharacter_Kill, DamageType) == 0x000008, "Member 'PhxCharacter_Kill::DamageType' has a wrong offset!");

// Function Phoenix.PhxCharacter.OnBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxCharacter_OnBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComp;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_OnBeginOverlap) == 0x000008, "Wrong alignment on PhxCharacter_OnBeginOverlap");
static_assert(sizeof(PhxCharacter_OnBeginOverlap) == 0x0000A8, "Wrong size on PhxCharacter_OnBeginOverlap");
static_assert(offsetof(PhxCharacter_OnBeginOverlap, OverlappedComp) == 0x000000, "Member 'PhxCharacter_OnBeginOverlap::OverlappedComp' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnBeginOverlap, OtherActor) == 0x000008, "Member 'PhxCharacter_OnBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnBeginOverlap, OtherComp) == 0x000010, "Member 'PhxCharacter_OnBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxCharacter_OnBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnBeginOverlap, bFromSweep) == 0x00001C, "Member 'PhxCharacter_OnBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnBeginOverlap, SweepResult) == 0x000020, "Member 'PhxCharacter_OnBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxCharacter.OnBodyPartDead
// 0x0020 (0x0020 - 0x0000)
struct PhxCharacter_OnBodyPartDead final
{
public:
	TArray<EPhxBodyPartType>                      KilledParts;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
	class AActor*                                 InstigatorActor;                                   // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OwningCharacter;                                   // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_OnBodyPartDead) == 0x000008, "Wrong alignment on PhxCharacter_OnBodyPartDead");
static_assert(sizeof(PhxCharacter_OnBodyPartDead) == 0x000020, "Wrong size on PhxCharacter_OnBodyPartDead");
static_assert(offsetof(PhxCharacter_OnBodyPartDead, KilledParts) == 0x000000, "Member 'PhxCharacter_OnBodyPartDead::KilledParts' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnBodyPartDead, InstigatorActor) == 0x000010, "Member 'PhxCharacter_OnBodyPartDead::InstigatorActor' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnBodyPartDead, OwningCharacter) == 0x000018, "Member 'PhxCharacter_OnBodyPartDead::OwningCharacter' has a wrong offset!");

// Function Phoenix.PhxCharacter.OnEndOverlap
// 0x0020 (0x0020 - 0x0000)
struct PhxCharacter_OnEndOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComp;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_OnEndOverlap) == 0x000008, "Wrong alignment on PhxCharacter_OnEndOverlap");
static_assert(sizeof(PhxCharacter_OnEndOverlap) == 0x000020, "Wrong size on PhxCharacter_OnEndOverlap");
static_assert(offsetof(PhxCharacter_OnEndOverlap, OverlappedComp) == 0x000000, "Member 'PhxCharacter_OnEndOverlap::OverlappedComp' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnEndOverlap, OtherActor) == 0x000008, "Member 'PhxCharacter_OnEndOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnEndOverlap, OtherComp) == 0x000010, "Member 'PhxCharacter_OnEndOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnEndOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxCharacter_OnEndOverlap::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PhxCharacter.OnLandedReceived
// 0x0088 (0x0088 - 0x0000)
struct PhxCharacter_OnLandedReceived final
{
public:
	struct FHitResult                             Hit;                                               // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_OnLandedReceived) == 0x000004, "Wrong alignment on PhxCharacter_OnLandedReceived");
static_assert(sizeof(PhxCharacter_OnLandedReceived) == 0x000088, "Wrong size on PhxCharacter_OnLandedReceived");
static_assert(offsetof(PhxCharacter_OnLandedReceived, Hit) == 0x000000, "Member 'PhxCharacter_OnLandedReceived::Hit' has a wrong offset!");

// Function Phoenix.PhxCharacter.OnTagUpdated
// 0x000C (0x000C - 0x0000)
struct PhxCharacter_OnTagUpdated final
{
public:
	struct FGameplayTag                           Tag;                                               // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bExist;                                            // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_OnTagUpdated) == 0x000004, "Wrong alignment on PhxCharacter_OnTagUpdated");
static_assert(sizeof(PhxCharacter_OnTagUpdated) == 0x00000C, "Wrong size on PhxCharacter_OnTagUpdated");
static_assert(offsetof(PhxCharacter_OnTagUpdated, Tag) == 0x000000, "Member 'PhxCharacter_OnTagUpdated::Tag' has a wrong offset!");
static_assert(offsetof(PhxCharacter_OnTagUpdated, bExist) == 0x000008, "Member 'PhxCharacter_OnTagUpdated::bExist' has a wrong offset!");

// Function Phoenix.PhxCharacter.ReactToWeaponBreak
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_ReactToWeaponBreak final
{
public:
	class AEquippable*                            Equipment;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_ReactToWeaponBreak) == 0x000008, "Wrong alignment on PhxCharacter_ReactToWeaponBreak");
static_assert(sizeof(PhxCharacter_ReactToWeaponBreak) == 0x000008, "Wrong size on PhxCharacter_ReactToWeaponBreak");
static_assert(offsetof(PhxCharacter_ReactToWeaponBreak, Equipment) == 0x000000, "Member 'PhxCharacter_ReactToWeaponBreak::Equipment' has a wrong offset!");

// Function Phoenix.PhxCharacter.RequestActionAbort
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_RequestActionAbort final
{
public:
	bool                                          bPlayerRequested;                                  // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_RequestActionAbort) == 0x000001, "Wrong alignment on PhxCharacter_RequestActionAbort");
static_assert(sizeof(PhxCharacter_RequestActionAbort) == 0x000001, "Wrong size on PhxCharacter_RequestActionAbort");
static_assert(offsetof(PhxCharacter_RequestActionAbort, bPlayerRequested) == 0x000000, "Member 'PhxCharacter_RequestActionAbort::bPlayerRequested' has a wrong offset!");

// Function Phoenix.PhxCharacter.RequestMovementSplineStateEnter
// 0x0030 (0x0030 - 0x0000)
struct PhxCharacter_RequestMovementSplineStateEnter final
{
public:
	struct FPhxMovementSplineStateRequest         InRequest;                                         // 0x0000(0x0030)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_RequestMovementSplineStateEnter) == 0x000008, "Wrong alignment on PhxCharacter_RequestMovementSplineStateEnter");
static_assert(sizeof(PhxCharacter_RequestMovementSplineStateEnter) == 0x000030, "Wrong size on PhxCharacter_RequestMovementSplineStateEnter");
static_assert(offsetof(PhxCharacter_RequestMovementSplineStateEnter, InRequest) == 0x000000, "Member 'PhxCharacter_RequestMovementSplineStateEnter::InRequest' has a wrong offset!");

// Function Phoenix.PhxCharacter.RequestSnowcatOccupantState
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacter_RequestSnowcatOccupantState final
{
public:
	class APhxSnowcatSpline*                      InSnowcatSpline;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USceneComponent*                        InAttachComponent;                                 // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               LocationRule;                                      // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               RotationRule;                                      // 0x0011(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12[0x6];                                       // 0x0012(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_RequestSnowcatOccupantState) == 0x000008, "Wrong alignment on PhxCharacter_RequestSnowcatOccupantState");
static_assert(sizeof(PhxCharacter_RequestSnowcatOccupantState) == 0x000018, "Wrong size on PhxCharacter_RequestSnowcatOccupantState");
static_assert(offsetof(PhxCharacter_RequestSnowcatOccupantState, InSnowcatSpline) == 0x000000, "Member 'PhxCharacter_RequestSnowcatOccupantState::InSnowcatSpline' has a wrong offset!");
static_assert(offsetof(PhxCharacter_RequestSnowcatOccupantState, InAttachComponent) == 0x000008, "Member 'PhxCharacter_RequestSnowcatOccupantState::InAttachComponent' has a wrong offset!");
static_assert(offsetof(PhxCharacter_RequestSnowcatOccupantState, LocationRule) == 0x000010, "Member 'PhxCharacter_RequestSnowcatOccupantState::LocationRule' has a wrong offset!");
static_assert(offsetof(PhxCharacter_RequestSnowcatOccupantState, RotationRule) == 0x000011, "Member 'PhxCharacter_RequestSnowcatOccupantState::RotationRule' has a wrong offset!");

// Function Phoenix.PhxCharacter.SetAimRequest
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_SetAimRequest final
{
public:
	bool                                          bSet;                                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_SetAimRequest) == 0x000001, "Wrong alignment on PhxCharacter_SetAimRequest");
static_assert(sizeof(PhxCharacter_SetAimRequest) == 0x000001, "Wrong size on PhxCharacter_SetAimRequest");
static_assert(offsetof(PhxCharacter_SetAimRequest, bSet) == 0x000000, "Member 'PhxCharacter_SetAimRequest::bSet' has a wrong offset!");

// Function Phoenix.PhxCharacter.SetCanPerformMeleeAttack
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_SetCanPerformMeleeAttack final
{
public:
	bool                                          bCanMelee;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_SetCanPerformMeleeAttack) == 0x000001, "Wrong alignment on PhxCharacter_SetCanPerformMeleeAttack");
static_assert(sizeof(PhxCharacter_SetCanPerformMeleeAttack) == 0x000001, "Wrong size on PhxCharacter_SetCanPerformMeleeAttack");
static_assert(offsetof(PhxCharacter_SetCanPerformMeleeAttack, bCanMelee) == 0x000000, "Member 'PhxCharacter_SetCanPerformMeleeAttack::bCanMelee' has a wrong offset!");

// Function Phoenix.PhxCharacter.SetCanShoot
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_SetCanShoot final
{
public:
	bool                                          bCanShoot;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_SetCanShoot) == 0x000001, "Wrong alignment on PhxCharacter_SetCanShoot");
static_assert(sizeof(PhxCharacter_SetCanShoot) == 0x000001, "Wrong size on PhxCharacter_SetCanShoot");
static_assert(offsetof(PhxCharacter_SetCanShoot, bCanShoot) == 0x000000, "Member 'PhxCharacter_SetCanShoot::bCanShoot' has a wrong offset!");

// Function Phoenix.PhxCharacter.SetForceInBreathableEnvironment
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_SetForceInBreathableEnvironment final
{
public:
	bool                                          bForceBreathable;                                  // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_SetForceInBreathableEnvironment) == 0x000001, "Wrong alignment on PhxCharacter_SetForceInBreathableEnvironment");
static_assert(sizeof(PhxCharacter_SetForceInBreathableEnvironment) == 0x000001, "Wrong size on PhxCharacter_SetForceInBreathableEnvironment");
static_assert(offsetof(PhxCharacter_SetForceInBreathableEnvironment, bForceBreathable) == 0x000000, "Member 'PhxCharacter_SetForceInBreathableEnvironment::bForceBreathable' has a wrong offset!");

// Function Phoenix.PhxCharacter.SetIsPrevizVideoPlaying
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_SetIsPrevizVideoPlaying final
{
public:
	bool                                          bVideoPlaying;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_SetIsPrevizVideoPlaying) == 0x000001, "Wrong alignment on PhxCharacter_SetIsPrevizVideoPlaying");
static_assert(sizeof(PhxCharacter_SetIsPrevizVideoPlaying) == 0x000001, "Wrong size on PhxCharacter_SetIsPrevizVideoPlaying");
static_assert(offsetof(PhxCharacter_SetIsPrevizVideoPlaying, bVideoPlaying) == 0x000000, "Member 'PhxCharacter_SetIsPrevizVideoPlaying::bVideoPlaying' has a wrong offset!");

// Function Phoenix.PhxCharacter.SetReload
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_SetReload final
{
public:
	bool                                          bReload;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_SetReload) == 0x000001, "Wrong alignment on PhxCharacter_SetReload");
static_assert(sizeof(PhxCharacter_SetReload) == 0x000001, "Wrong size on PhxCharacter_SetReload");
static_assert(offsetof(PhxCharacter_SetReload, bReload) == 0x000000, "Member 'PhxCharacter_SetReload::bReload' has a wrong offset!");

// Function Phoenix.PhxCharacter.SetStompLocked
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_SetStompLocked final
{
public:
	bool                                          bLocked;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_SetStompLocked) == 0x000001, "Wrong alignment on PhxCharacter_SetStompLocked");
static_assert(sizeof(PhxCharacter_SetStompLocked) == 0x000001, "Wrong size on PhxCharacter_SetStompLocked");
static_assert(offsetof(PhxCharacter_SetStompLocked, bLocked) == 0x000000, "Member 'PhxCharacter_SetStompLocked::bLocked' has a wrong offset!");

// Function Phoenix.PhxCharacter.ShouldEnableClothSim
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_ShouldEnableClothSim final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_ShouldEnableClothSim) == 0x000001, "Wrong alignment on PhxCharacter_ShouldEnableClothSim");
static_assert(sizeof(PhxCharacter_ShouldEnableClothSim) == 0x000001, "Wrong size on PhxCharacter_ShouldEnableClothSim");
static_assert(offsetof(PhxCharacter_ShouldEnableClothSim, ReturnValue) == 0x000000, "Member 'PhxCharacter_ShouldEnableClothSim::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.StartPhysics
// 0x0024 (0x0024 - 0x0000)
struct PhxCharacter_StartPhysics final
{
public:
	class FName                                   BodyName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ProfileName;                                       // 0x0008(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ConstraintProfileName;                             // 0x0010(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIncludeSelf;                                      // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x3];                                       // 0x0019(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         BlendInTime;                                       // 0x001C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECharacterPhysicsBlendType                    Type;                                              // 0x0020(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x3];                                       // 0x0021(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_StartPhysics) == 0x000004, "Wrong alignment on PhxCharacter_StartPhysics");
static_assert(sizeof(PhxCharacter_StartPhysics) == 0x000024, "Wrong size on PhxCharacter_StartPhysics");
static_assert(offsetof(PhxCharacter_StartPhysics, BodyName) == 0x000000, "Member 'PhxCharacter_StartPhysics::BodyName' has a wrong offset!");
static_assert(offsetof(PhxCharacter_StartPhysics, ProfileName) == 0x000008, "Member 'PhxCharacter_StartPhysics::ProfileName' has a wrong offset!");
static_assert(offsetof(PhxCharacter_StartPhysics, ConstraintProfileName) == 0x000010, "Member 'PhxCharacter_StartPhysics::ConstraintProfileName' has a wrong offset!");
static_assert(offsetof(PhxCharacter_StartPhysics, bIncludeSelf) == 0x000018, "Member 'PhxCharacter_StartPhysics::bIncludeSelf' has a wrong offset!");
static_assert(offsetof(PhxCharacter_StartPhysics, BlendInTime) == 0x00001C, "Member 'PhxCharacter_StartPhysics::BlendInTime' has a wrong offset!");
static_assert(offsetof(PhxCharacter_StartPhysics, Type) == 0x000020, "Member 'PhxCharacter_StartPhysics::Type' has a wrong offset!");

// Function Phoenix.PhxCharacter.CanPerformMeleeAttack
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_CanPerformMeleeAttack final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_CanPerformMeleeAttack) == 0x000001, "Wrong alignment on PhxCharacter_CanPerformMeleeAttack");
static_assert(sizeof(PhxCharacter_CanPerformMeleeAttack) == 0x000001, "Wrong size on PhxCharacter_CanPerformMeleeAttack");
static_assert(offsetof(PhxCharacter_CanPerformMeleeAttack, ReturnValue) == 0x000000, "Member 'PhxCharacter_CanPerformMeleeAttack::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.CanShoot
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_CanShoot final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_CanShoot) == 0x000001, "Wrong alignment on PhxCharacter_CanShoot");
static_assert(sizeof(PhxCharacter_CanShoot) == 0x000001, "Wrong size on PhxCharacter_CanShoot");
static_assert(offsetof(PhxCharacter_CanShoot, ReturnValue) == 0x000000, "Member 'PhxCharacter_CanShoot::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.DoesBoneExists
// 0x000C (0x000C - 0x0000)
struct PhxCharacter_DoesBoneExists final
{
public:
	class FName                                   BoneName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_DoesBoneExists) == 0x000004, "Wrong alignment on PhxCharacter_DoesBoneExists");
static_assert(sizeof(PhxCharacter_DoesBoneExists) == 0x00000C, "Wrong size on PhxCharacter_DoesBoneExists");
static_assert(offsetof(PhxCharacter_DoesBoneExists, BoneName) == 0x000000, "Member 'PhxCharacter_DoesBoneExists::BoneName' has a wrong offset!");
static_assert(offsetof(PhxCharacter_DoesBoneExists, ReturnValue) == 0x000008, "Member 'PhxCharacter_DoesBoneExists::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetBodyMesh
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetBodyMesh final
{
public:
	class USkeletalMeshComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetBodyMesh) == 0x000008, "Wrong alignment on PhxCharacter_GetBodyMesh");
static_assert(sizeof(PhxCharacter_GetBodyMesh) == 0x000008, "Wrong size on PhxCharacter_GetBodyMesh");
static_assert(offsetof(PhxCharacter_GetBodyMesh, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetBodyMesh::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetBodySkeletalMeshComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetBodySkeletalMeshComponent final
{
public:
	class USkeletalMeshComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetBodySkeletalMeshComponent) == 0x000008, "Wrong alignment on PhxCharacter_GetBodySkeletalMeshComponent");
static_assert(sizeof(PhxCharacter_GetBodySkeletalMeshComponent) == 0x000008, "Wrong size on PhxCharacter_GetBodySkeletalMeshComponent");
static_assert(offsetof(PhxCharacter_GetBodySkeletalMeshComponent, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetBodySkeletalMeshComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetBoneLocation
// 0x0020 (0x0020 - 0x0000)
struct PhxCharacter_GetBoneLocation final
{
public:
	class FName                                   BoneName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                RelativeOffset;                                    // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x0014(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetBoneLocation) == 0x000004, "Wrong alignment on PhxCharacter_GetBoneLocation");
static_assert(sizeof(PhxCharacter_GetBoneLocation) == 0x000020, "Wrong size on PhxCharacter_GetBoneLocation");
static_assert(offsetof(PhxCharacter_GetBoneLocation, BoneName) == 0x000000, "Member 'PhxCharacter_GetBoneLocation::BoneName' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetBoneLocation, RelativeOffset) == 0x000008, "Member 'PhxCharacter_GetBoneLocation::RelativeOffset' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetBoneLocation, ReturnValue) == 0x000014, "Member 'PhxCharacter_GetBoneLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetCameraActor
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetCameraActor final
{
public:
	class ACameraActor*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetCameraActor) == 0x000008, "Wrong alignment on PhxCharacter_GetCameraActor");
static_assert(sizeof(PhxCharacter_GetCameraActor) == 0x000008, "Wrong size on PhxCharacter_GetCameraActor");
static_assert(offsetof(PhxCharacter_GetCameraActor, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetCameraActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetCameraRig
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetCameraRig final
{
public:
	class APhxCameraRig*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetCameraRig) == 0x000008, "Wrong alignment on PhxCharacter_GetCameraRig");
static_assert(sizeof(PhxCharacter_GetCameraRig) == 0x000008, "Wrong size on PhxCharacter_GetCameraRig");
static_assert(offsetof(PhxCharacter_GetCameraRig, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetCameraRig::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetCapsuleBottom
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacter_GetCapsuleBottom final
{
public:
	struct FVector                                RelativeOffset;                                    // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x000C(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetCapsuleBottom) == 0x000004, "Wrong alignment on PhxCharacter_GetCapsuleBottom");
static_assert(sizeof(PhxCharacter_GetCapsuleBottom) == 0x000018, "Wrong size on PhxCharacter_GetCapsuleBottom");
static_assert(offsetof(PhxCharacter_GetCapsuleBottom, RelativeOffset) == 0x000000, "Member 'PhxCharacter_GetCapsuleBottom::RelativeOffset' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetCapsuleBottom, ReturnValue) == 0x00000C, "Member 'PhxCharacter_GetCapsuleBottom::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetCapsuleTop
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacter_GetCapsuleTop final
{
public:
	struct FVector                                RelativeOffset;                                    // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x000C(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetCapsuleTop) == 0x000004, "Wrong alignment on PhxCharacter_GetCapsuleTop");
static_assert(sizeof(PhxCharacter_GetCapsuleTop) == 0x000018, "Wrong size on PhxCharacter_GetCapsuleTop");
static_assert(offsetof(PhxCharacter_GetCapsuleTop, RelativeOffset) == 0x000000, "Member 'PhxCharacter_GetCapsuleTop::RelativeOffset' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetCapsuleTop, ReturnValue) == 0x00000C, "Member 'PhxCharacter_GetCapsuleTop::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetCharacterDefinition
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetCharacterDefinition final
{
public:
	class UPhxCharacterDefinition*                ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetCharacterDefinition) == 0x000008, "Wrong alignment on PhxCharacter_GetCharacterDefinition");
static_assert(sizeof(PhxCharacter_GetCharacterDefinition) == 0x000008, "Wrong size on PhxCharacter_GetCharacterDefinition");
static_assert(offsetof(PhxCharacter_GetCharacterDefinition, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetCharacterDefinition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetCharacterTag
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetCharacterTag final
{
public:
	struct FGameplayTag                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetCharacterTag) == 0x000004, "Wrong alignment on PhxCharacter_GetCharacterTag");
static_assert(sizeof(PhxCharacter_GetCharacterTag) == 0x000008, "Wrong size on PhxCharacter_GetCharacterTag");
static_assert(offsetof(PhxCharacter_GetCharacterTag, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetCharacterTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetClothSimMeshes
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacter_GetClothSimMeshes final
{
public:
	TArray<class USkeletalMeshComponent*>         ReturnValue;                                       // 0x0000(0x0010)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetClothSimMeshes) == 0x000008, "Wrong alignment on PhxCharacter_GetClothSimMeshes");
static_assert(sizeof(PhxCharacter_GetClothSimMeshes) == 0x000010, "Wrong size on PhxCharacter_GetClothSimMeshes");
static_assert(offsetof(PhxCharacter_GetClothSimMeshes, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetClothSimMeshes::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetDesiredMoveDirection
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacter_GetDesiredMoveDirection final
{
public:
	bool                                          AllowZero;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                ReturnValue;                                       // 0x0004(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetDesiredMoveDirection) == 0x000004, "Wrong alignment on PhxCharacter_GetDesiredMoveDirection");
static_assert(sizeof(PhxCharacter_GetDesiredMoveDirection) == 0x000010, "Wrong size on PhxCharacter_GetDesiredMoveDirection");
static_assert(offsetof(PhxCharacter_GetDesiredMoveDirection, AllowZero) == 0x000000, "Member 'PhxCharacter_GetDesiredMoveDirection::AllowZero' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetDesiredMoveDirection, ReturnValue) == 0x000004, "Member 'PhxCharacter_GetDesiredMoveDirection::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetEquipmentAttachParent
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetEquipmentAttachParent final
{
public:
	class USceneComponent*                        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetEquipmentAttachParent) == 0x000008, "Wrong alignment on PhxCharacter_GetEquipmentAttachParent");
static_assert(sizeof(PhxCharacter_GetEquipmentAttachParent) == 0x000008, "Wrong size on PhxCharacter_GetEquipmentAttachParent");
static_assert(offsetof(PhxCharacter_GetEquipmentAttachParent, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetEquipmentAttachParent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetEquipped
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetEquipped final
{
public:
	class AEquippable*                            ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetEquipped) == 0x000008, "Wrong alignment on PhxCharacter_GetEquipped");
static_assert(sizeof(PhxCharacter_GetEquipped) == 0x000008, "Wrong size on PhxCharacter_GetEquipped");
static_assert(offsetof(PhxCharacter_GetEquipped, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetEquipped::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetFlashlightComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetFlashlightComponent final
{
public:
	class UPhxFlashlightComponent*                ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetFlashlightComponent) == 0x000008, "Wrong alignment on PhxCharacter_GetFlashlightComponent");
static_assert(sizeof(PhxCharacter_GetFlashlightComponent) == 0x000008, "Wrong size on PhxCharacter_GetFlashlightComponent");
static_assert(offsetof(PhxCharacter_GetFlashlightComponent, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetFlashlightComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetFloorLocation
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacter_GetFloorLocation final
{
public:
	struct FVector                                RelativeOffset;                                    // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x000C(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetFloorLocation) == 0x000004, "Wrong alignment on PhxCharacter_GetFloorLocation");
static_assert(sizeof(PhxCharacter_GetFloorLocation) == 0x000018, "Wrong size on PhxCharacter_GetFloorLocation");
static_assert(offsetof(PhxCharacter_GetFloorLocation, RelativeOffset) == 0x000000, "Member 'PhxCharacter_GetFloorLocation::RelativeOffset' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetFloorLocation, ReturnValue) == 0x00000C, "Member 'PhxCharacter_GetFloorLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetFootfallVFX
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacter_GetFootfallVFX final
{
public:
	EPhysicalSurface                              SurfaceType;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Speed;                                             // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNiagaraSystem*                         ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetFootfallVFX) == 0x000008, "Wrong alignment on PhxCharacter_GetFootfallVFX");
static_assert(sizeof(PhxCharacter_GetFootfallVFX) == 0x000010, "Wrong size on PhxCharacter_GetFootfallVFX");
static_assert(offsetof(PhxCharacter_GetFootfallVFX, SurfaceType) == 0x000000, "Member 'PhxCharacter_GetFootfallVFX::SurfaceType' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetFootfallVFX, Speed) == 0x000004, "Member 'PhxCharacter_GetFootfallVFX::Speed' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetFootfallVFX, ReturnValue) == 0x000008, "Member 'PhxCharacter_GetFootfallVFX::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetForceHeadTrackingLookAtLocation
// 0x000C (0x000C - 0x0000)
struct PhxCharacter_GetForceHeadTrackingLookAtLocation final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetForceHeadTrackingLookAtLocation) == 0x000004, "Wrong alignment on PhxCharacter_GetForceHeadTrackingLookAtLocation");
static_assert(sizeof(PhxCharacter_GetForceHeadTrackingLookAtLocation) == 0x00000C, "Wrong size on PhxCharacter_GetForceHeadTrackingLookAtLocation");
static_assert(offsetof(PhxCharacter_GetForceHeadTrackingLookAtLocation, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetForceHeadTrackingLookAtLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetHasTargetToLookAt
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_GetHasTargetToLookAt final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetHasTargetToLookAt) == 0x000001, "Wrong alignment on PhxCharacter_GetHasTargetToLookAt");
static_assert(sizeof(PhxCharacter_GetHasTargetToLookAt) == 0x000001, "Wrong size on PhxCharacter_GetHasTargetToLookAt");
static_assert(offsetof(PhxCharacter_GetHasTargetToLookAt, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetHasTargetToLookAt::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetHealthPercentage
// 0x0004 (0x0004 - 0x0000)
struct PhxCharacter_GetHealthPercentage final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetHealthPercentage) == 0x000004, "Wrong alignment on PhxCharacter_GetHealthPercentage");
static_assert(sizeof(PhxCharacter_GetHealthPercentage) == 0x000004, "Wrong size on PhxCharacter_GetHealthPercentage");
static_assert(offsetof(PhxCharacter_GetHealthPercentage, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetHealthPercentage::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetInteractionComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetInteractionComponent final
{
public:
	class UPhxCharacterInteractionComponent*      ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetInteractionComponent) == 0x000008, "Wrong alignment on PhxCharacter_GetInteractionComponent");
static_assert(sizeof(PhxCharacter_GetInteractionComponent) == 0x000008, "Wrong size on PhxCharacter_GetInteractionComponent");
static_assert(offsetof(PhxCharacter_GetInteractionComponent, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetInteractionComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetIsAiming
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_GetIsAiming final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetIsAiming) == 0x000001, "Wrong alignment on PhxCharacter_GetIsAiming");
static_assert(sizeof(PhxCharacter_GetIsAiming) == 0x000001, "Wrong size on PhxCharacter_GetIsAiming");
static_assert(offsetof(PhxCharacter_GetIsAiming, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetIsAiming::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetMeshBoneData
// 0x00D8 (0x00D8 - 0x0000)
struct PhxCharacter_GetMeshBoneData final
{
public:
	class FName                                   BoneName;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMeshBoneData                          BoneData;                                          // 0x0008(0x00C8)(Parm, OutParm, ContainsInstancedReference, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00D0(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D1[0x7];                                       // 0x00D1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_GetMeshBoneData) == 0x000008, "Wrong alignment on PhxCharacter_GetMeshBoneData");
static_assert(sizeof(PhxCharacter_GetMeshBoneData) == 0x0000D8, "Wrong size on PhxCharacter_GetMeshBoneData");
static_assert(offsetof(PhxCharacter_GetMeshBoneData, BoneName) == 0x000000, "Member 'PhxCharacter_GetMeshBoneData::BoneName' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetMeshBoneData, BoneData) == 0x000008, "Member 'PhxCharacter_GetMeshBoneData::BoneData' has a wrong offset!");
static_assert(offsetof(PhxCharacter_GetMeshBoneData, ReturnValue) == 0x0000D0, "Member 'PhxCharacter_GetMeshBoneData::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetPlayerController
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_GetPlayerController final
{
public:
	class APhxPlayerController*                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetPlayerController) == 0x000008, "Wrong alignment on PhxCharacter_GetPlayerController");
static_assert(sizeof(PhxCharacter_GetPlayerController) == 0x000008, "Wrong size on PhxCharacter_GetPlayerController");
static_assert(offsetof(PhxCharacter_GetPlayerController, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetPlayerController::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.GetStance
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_GetStance final
{
public:
	ECharacterStance                              ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_GetStance) == 0x000001, "Wrong alignment on PhxCharacter_GetStance");
static_assert(sizeof(PhxCharacter_GetStance) == 0x000001, "Wrong size on PhxCharacter_GetStance");
static_assert(offsetof(PhxCharacter_GetStance, ReturnValue) == 0x000000, "Member 'PhxCharacter_GetStance::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsCharacterCrouched
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_IsCharacterCrouched final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_IsCharacterCrouched) == 0x000001, "Wrong alignment on PhxCharacter_IsCharacterCrouched");
static_assert(sizeof(PhxCharacter_IsCharacterCrouched) == 0x000001, "Wrong size on PhxCharacter_IsCharacterCrouched");
static_assert(offsetof(PhxCharacter_IsCharacterCrouched, ReturnValue) == 0x000000, "Member 'PhxCharacter_IsCharacterCrouched::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsCharacterInState
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacter_IsCharacterInState final
{
public:
	TSubclassOf<class UState>                     StateClass;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_IsCharacterInState) == 0x000008, "Wrong alignment on PhxCharacter_IsCharacterInState");
static_assert(sizeof(PhxCharacter_IsCharacterInState) == 0x000010, "Wrong size on PhxCharacter_IsCharacterInState");
static_assert(offsetof(PhxCharacter_IsCharacterInState, StateClass) == 0x000000, "Member 'PhxCharacter_IsCharacterInState::StateClass' has a wrong offset!");
static_assert(offsetof(PhxCharacter_IsCharacterInState, ReturnValue) == 0x000008, "Member 'PhxCharacter_IsCharacterInState::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsCharacterInStateId
// 0x000C (0x000C - 0x0000)
struct PhxCharacter_IsCharacterInStateId final
{
public:
	class FName                                   ID;                                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_IsCharacterInStateId) == 0x000004, "Wrong alignment on PhxCharacter_IsCharacterInStateId");
static_assert(sizeof(PhxCharacter_IsCharacterInStateId) == 0x00000C, "Wrong size on PhxCharacter_IsCharacterInStateId");
static_assert(offsetof(PhxCharacter_IsCharacterInStateId, ID) == 0x000000, "Member 'PhxCharacter_IsCharacterInStateId::ID' has a wrong offset!");
static_assert(offsetof(PhxCharacter_IsCharacterInStateId, ReturnValue) == 0x000008, "Member 'PhxCharacter_IsCharacterInStateId::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsControlledByAdHocCinematic
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_IsControlledByAdHocCinematic final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_IsControlledByAdHocCinematic) == 0x000001, "Wrong alignment on PhxCharacter_IsControlledByAdHocCinematic");
static_assert(sizeof(PhxCharacter_IsControlledByAdHocCinematic) == 0x000001, "Wrong size on PhxCharacter_IsControlledByAdHocCinematic");
static_assert(offsetof(PhxCharacter_IsControlledByAdHocCinematic, ReturnValue) == 0x000000, "Member 'PhxCharacter_IsControlledByAdHocCinematic::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsControlledByScriptedEvent
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_IsControlledByScriptedEvent final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_IsControlledByScriptedEvent) == 0x000001, "Wrong alignment on PhxCharacter_IsControlledByScriptedEvent");
static_assert(sizeof(PhxCharacter_IsControlledByScriptedEvent) == 0x000001, "Wrong size on PhxCharacter_IsControlledByScriptedEvent");
static_assert(offsetof(PhxCharacter_IsControlledByScriptedEvent, ReturnValue) == 0x000000, "Member 'PhxCharacter_IsControlledByScriptedEvent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsDead
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_IsDead final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_IsDead) == 0x000001, "Wrong alignment on PhxCharacter_IsDead");
static_assert(sizeof(PhxCharacter_IsDead) == 0x000001, "Wrong size on PhxCharacter_IsDead");
static_assert(offsetof(PhxCharacter_IsDead, ReturnValue) == 0x000000, "Member 'PhxCharacter_IsDead::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsInTaggedTriggerVolume
// 0x000C (0x000C - 0x0000)
struct PhxCharacter_IsInTaggedTriggerVolume final
{
public:
	class FName                                   TagName;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_IsInTaggedTriggerVolume) == 0x000004, "Wrong alignment on PhxCharacter_IsInTaggedTriggerVolume");
static_assert(sizeof(PhxCharacter_IsInTaggedTriggerVolume) == 0x00000C, "Wrong size on PhxCharacter_IsInTaggedTriggerVolume");
static_assert(offsetof(PhxCharacter_IsInTaggedTriggerVolume, TagName) == 0x000000, "Member 'PhxCharacter_IsInTaggedTriggerVolume::TagName' has a wrong offset!");
static_assert(offsetof(PhxCharacter_IsInTaggedTriggerVolume, ReturnValue) == 0x000008, "Member 'PhxCharacter_IsInTaggedTriggerVolume::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsInvulnerableTo
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacter_IsInvulnerableTo final
{
public:
	class APhxCharacter*                          Attacker;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_IsInvulnerableTo) == 0x000008, "Wrong alignment on PhxCharacter_IsInvulnerableTo");
static_assert(sizeof(PhxCharacter_IsInvulnerableTo) == 0x000010, "Wrong size on PhxCharacter_IsInvulnerableTo");
static_assert(offsetof(PhxCharacter_IsInvulnerableTo, Attacker) == 0x000000, "Member 'PhxCharacter_IsInvulnerableTo::Attacker' has a wrong offset!");
static_assert(offsetof(PhxCharacter_IsInvulnerableTo, ReturnValue) == 0x000008, "Member 'PhxCharacter_IsInvulnerableTo::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsUngrabbableBy
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacter_IsUngrabbableBy final
{
public:
	class APhxCharacter*                          Attacker;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_IsUngrabbableBy) == 0x000008, "Wrong alignment on PhxCharacter_IsUngrabbableBy");
static_assert(sizeof(PhxCharacter_IsUngrabbableBy) == 0x000010, "Wrong size on PhxCharacter_IsUngrabbableBy");
static_assert(offsetof(PhxCharacter_IsUngrabbableBy, Attacker) == 0x000000, "Member 'PhxCharacter_IsUngrabbableBy::Attacker' has a wrong offset!");
static_assert(offsetof(PhxCharacter_IsUngrabbableBy, ReturnValue) == 0x000008, "Member 'PhxCharacter_IsUngrabbableBy::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.IsUninterruptibleBy
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacter_IsUninterruptibleBy final
{
public:
	class APhxCharacter*                          Attacker;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UClass*                                 DamageTypeClass;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacter_IsUninterruptibleBy) == 0x000008, "Wrong alignment on PhxCharacter_IsUninterruptibleBy");
static_assert(sizeof(PhxCharacter_IsUninterruptibleBy) == 0x000018, "Wrong size on PhxCharacter_IsUninterruptibleBy");
static_assert(offsetof(PhxCharacter_IsUninterruptibleBy, Attacker) == 0x000000, "Member 'PhxCharacter_IsUninterruptibleBy::Attacker' has a wrong offset!");
static_assert(offsetof(PhxCharacter_IsUninterruptibleBy, DamageTypeClass) == 0x000008, "Member 'PhxCharacter_IsUninterruptibleBy::DamageTypeClass' has a wrong offset!");
static_assert(offsetof(PhxCharacter_IsUninterruptibleBy, ReturnValue) == 0x000010, "Member 'PhxCharacter_IsUninterruptibleBy::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.LockOutActions
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_LockOutActions final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_LockOutActions) == 0x000001, "Wrong alignment on PhxCharacter_LockOutActions");
static_assert(sizeof(PhxCharacter_LockOutActions) == 0x000001, "Wrong size on PhxCharacter_LockOutActions");
static_assert(offsetof(PhxCharacter_LockOutActions, ReturnValue) == 0x000000, "Member 'PhxCharacter_LockOutActions::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.LockOutCorpseStomp
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_LockOutCorpseStomp final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_LockOutCorpseStomp) == 0x000001, "Wrong alignment on PhxCharacter_LockOutCorpseStomp");
static_assert(sizeof(PhxCharacter_LockOutCorpseStomp) == 0x000001, "Wrong size on PhxCharacter_LockOutCorpseStomp");
static_assert(offsetof(PhxCharacter_LockOutCorpseStomp, ReturnValue) == 0x000000, "Member 'PhxCharacter_LockOutCorpseStomp::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.LockOutEquipment
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_LockOutEquipment final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_LockOutEquipment) == 0x000001, "Wrong alignment on PhxCharacter_LockOutEquipment");
static_assert(sizeof(PhxCharacter_LockOutEquipment) == 0x000001, "Wrong size on PhxCharacter_LockOutEquipment");
static_assert(offsetof(PhxCharacter_LockOutEquipment, ReturnValue) == 0x000000, "Member 'PhxCharacter_LockOutEquipment::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.LockOutInteractions
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_LockOutInteractions final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_LockOutInteractions) == 0x000001, "Wrong alignment on PhxCharacter_LockOutInteractions");
static_assert(sizeof(PhxCharacter_LockOutInteractions) == 0x000001, "Wrong size on PhxCharacter_LockOutInteractions");
static_assert(offsetof(PhxCharacter_LockOutInteractions, ReturnValue) == 0x000000, "Member 'PhxCharacter_LockOutInteractions::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.LockOutMovement
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_LockOutMovement final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_LockOutMovement) == 0x000001, "Wrong alignment on PhxCharacter_LockOutMovement");
static_assert(sizeof(PhxCharacter_LockOutMovement) == 0x000001, "Wrong size on PhxCharacter_LockOutMovement");
static_assert(offsetof(PhxCharacter_LockOutMovement, ReturnValue) == 0x000000, "Member 'PhxCharacter_LockOutMovement::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.ReplaceMeshUserDataDefinition
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacter_ReplaceMeshUserDataDefinition final
{
public:
	class UPhxMeshUserDataDefinition*             PhxMeshUserDataDefinition;                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_ReplaceMeshUserDataDefinition) == 0x000008, "Wrong alignment on PhxCharacter_ReplaceMeshUserDataDefinition");
static_assert(sizeof(PhxCharacter_ReplaceMeshUserDataDefinition) == 0x000008, "Wrong size on PhxCharacter_ReplaceMeshUserDataDefinition");
static_assert(offsetof(PhxCharacter_ReplaceMeshUserDataDefinition, PhxMeshUserDataDefinition) == 0x000000, "Member 'PhxCharacter_ReplaceMeshUserDataDefinition::PhxMeshUserDataDefinition' has a wrong offset!");

// Function Phoenix.PhxCharacter.ShouldForceHeadtracking
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_ShouldForceHeadtracking final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_ShouldForceHeadtracking) == 0x000001, "Wrong alignment on PhxCharacter_ShouldForceHeadtracking");
static_assert(sizeof(PhxCharacter_ShouldForceHeadtracking) == 0x000001, "Wrong size on PhxCharacter_ShouldForceHeadtracking");
static_assert(offsetof(PhxCharacter_ShouldForceHeadtracking, ReturnValue) == 0x000000, "Member 'PhxCharacter_ShouldForceHeadtracking::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.ShouldPlayEnvironmentalAnim
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_ShouldPlayEnvironmentalAnim final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_ShouldPlayEnvironmentalAnim) == 0x000001, "Wrong alignment on PhxCharacter_ShouldPlayEnvironmentalAnim");
static_assert(sizeof(PhxCharacter_ShouldPlayEnvironmentalAnim) == 0x000001, "Wrong size on PhxCharacter_ShouldPlayEnvironmentalAnim");
static_assert(offsetof(PhxCharacter_ShouldPlayEnvironmentalAnim, ReturnValue) == 0x000000, "Member 'PhxCharacter_ShouldPlayEnvironmentalAnim::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.ShouldUseFlashlightWhenHeadTracking
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_ShouldUseFlashlightWhenHeadTracking final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_ShouldUseFlashlightWhenHeadTracking) == 0x000001, "Wrong alignment on PhxCharacter_ShouldUseFlashlightWhenHeadTracking");
static_assert(sizeof(PhxCharacter_ShouldUseFlashlightWhenHeadTracking) == 0x000001, "Wrong size on PhxCharacter_ShouldUseFlashlightWhenHeadTracking");
static_assert(offsetof(PhxCharacter_ShouldUseFlashlightWhenHeadTracking, ReturnValue) == 0x000000, "Member 'PhxCharacter_ShouldUseFlashlightWhenHeadTracking::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacter.UsingFlashlight
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacter_UsingFlashlight final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacter_UsingFlashlight) == 0x000001, "Wrong alignment on PhxCharacter_UsingFlashlight");
static_assert(sizeof(PhxCharacter_UsingFlashlight) == 0x000001, "Wrong size on PhxCharacter_UsingFlashlight");
static_assert(offsetof(PhxCharacter_UsingFlashlight, ReturnValue) == 0x000000, "Member 'PhxCharacter_UsingFlashlight::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacter.DynamicDropsItemDroppedChanged
// 0x0001 (0x0001 - 0x0000)
struct PhxAICharacter_DynamicDropsItemDroppedChanged final
{
public:
	bool                                          bItemDropped;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacter_DynamicDropsItemDroppedChanged) == 0x000001, "Wrong alignment on PhxAICharacter_DynamicDropsItemDroppedChanged");
static_assert(sizeof(PhxAICharacter_DynamicDropsItemDroppedChanged) == 0x000001, "Wrong size on PhxAICharacter_DynamicDropsItemDroppedChanged");
static_assert(offsetof(PhxAICharacter_DynamicDropsItemDroppedChanged, bItemDropped) == 0x000000, "Member 'PhxAICharacter_DynamicDropsItemDroppedChanged::bItemDropped' has a wrong offset!");

// Function Phoenix.PhxAICharacter.OnGRPCollidedDuringLaunched
// 0x0001 (0x0001 - 0x0000)
struct PhxAICharacter_OnGRPCollidedDuringLaunched final
{
public:
	EPhxGRPLaunchCollisionHitType                 LaunchCollisionHitType;                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacter_OnGRPCollidedDuringLaunched) == 0x000001, "Wrong alignment on PhxAICharacter_OnGRPCollidedDuringLaunched");
static_assert(sizeof(PhxAICharacter_OnGRPCollidedDuringLaunched) == 0x000001, "Wrong size on PhxAICharacter_OnGRPCollidedDuringLaunched");
static_assert(offsetof(PhxAICharacter_OnGRPCollidedDuringLaunched, LaunchCollisionHitType) == 0x000000, "Member 'PhxAICharacter_OnGRPCollidedDuringLaunched::LaunchCollisionHitType' has a wrong offset!");

// Function Phoenix.PhxAICharacter.OverrideSelectedTarget_DebugOnly
// 0x0008 (0x0008 - 0x0000)
struct PhxAICharacter_OverrideSelectedTarget_DebugOnly final
{
public:
	class AActor*                                 TargetActor;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacter_OverrideSelectedTarget_DebugOnly) == 0x000008, "Wrong alignment on PhxAICharacter_OverrideSelectedTarget_DebugOnly");
static_assert(sizeof(PhxAICharacter_OverrideSelectedTarget_DebugOnly) == 0x000008, "Wrong size on PhxAICharacter_OverrideSelectedTarget_DebugOnly");
static_assert(offsetof(PhxAICharacter_OverrideSelectedTarget_DebugOnly, TargetActor) == 0x000000, "Member 'PhxAICharacter_OverrideSelectedTarget_DebugOnly::TargetActor' has a wrong offset!");

// Function Phoenix.PhxAICharacter.GeHighContrastMenuAnimSequence
// 0x0008 (0x0008 - 0x0000)
struct PhxAICharacter_GeHighContrastMenuAnimSequence final
{
public:
	class UAnimSequence*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacter_GeHighContrastMenuAnimSequence) == 0x000008, "Wrong alignment on PhxAICharacter_GeHighContrastMenuAnimSequence");
static_assert(sizeof(PhxAICharacter_GeHighContrastMenuAnimSequence) == 0x000008, "Wrong size on PhxAICharacter_GeHighContrastMenuAnimSequence");
static_assert(offsetof(PhxAICharacter_GeHighContrastMenuAnimSequence, ReturnValue) == 0x000000, "Member 'PhxAICharacter_GeHighContrastMenuAnimSequence::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacter.GetAdditionalHighContrastMenuMeshes
// 0x0010 (0x0010 - 0x0000)
struct PhxAICharacter_GetAdditionalHighContrastMenuMeshes final
{
public:
	TArray<class USkeletalMesh*>                  OutSkelMeshes;                                     // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacter_GetAdditionalHighContrastMenuMeshes) == 0x000008, "Wrong alignment on PhxAICharacter_GetAdditionalHighContrastMenuMeshes");
static_assert(sizeof(PhxAICharacter_GetAdditionalHighContrastMenuMeshes) == 0x000010, "Wrong size on PhxAICharacter_GetAdditionalHighContrastMenuMeshes");
static_assert(offsetof(PhxAICharacter_GetAdditionalHighContrastMenuMeshes, OutSkelMeshes) == 0x000000, "Member 'PhxAICharacter_GetAdditionalHighContrastMenuMeshes::OutSkelMeshes' has a wrong offset!");

// Function Phoenix.PhxAICharacter.GetCharacterComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxAICharacter_GetCharacterComponent final
{
public:
	class UPhxAICharacterComponent*               ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacter_GetCharacterComponent) == 0x000008, "Wrong alignment on PhxAICharacter_GetCharacterComponent");
static_assert(sizeof(PhxAICharacter_GetCharacterComponent) == 0x000008, "Wrong size on PhxAICharacter_GetCharacterComponent");
static_assert(offsetof(PhxAICharacter_GetCharacterComponent, ReturnValue) == 0x000000, "Member 'PhxAICharacter_GetCharacterComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacter.GetDefensiveActionsComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxAICharacter_GetDefensiveActionsComponent final
{
public:
	class UPhxAIDefensiveActionsComponent*        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacter_GetDefensiveActionsComponent) == 0x000008, "Wrong alignment on PhxAICharacter_GetDefensiveActionsComponent");
static_assert(sizeof(PhxAICharacter_GetDefensiveActionsComponent) == 0x000008, "Wrong size on PhxAICharacter_GetDefensiveActionsComponent");
static_assert(offsetof(PhxAICharacter_GetDefensiveActionsComponent, ReturnValue) == 0x000000, "Member 'PhxAICharacter_GetDefensiveActionsComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacter.GetNumPPEChargesApplied
// 0x0004 (0x0004 - 0x0000)
struct PhxAICharacter_GetNumPPEChargesApplied final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacter_GetNumPPEChargesApplied) == 0x000004, "Wrong alignment on PhxAICharacter_GetNumPPEChargesApplied");
static_assert(sizeof(PhxAICharacter_GetNumPPEChargesApplied) == 0x000004, "Wrong size on PhxAICharacter_GetNumPPEChargesApplied");
static_assert(offsetof(PhxAICharacter_GetNumPPEChargesApplied, ReturnValue) == 0x000000, "Member 'PhxAICharacter_GetNumPPEChargesApplied::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacter.GetOffensiveActionsComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxAICharacter_GetOffensiveActionsComponent final
{
public:
	class UPhxAIOffensiveActionsComponent*        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacter_GetOffensiveActionsComponent) == 0x000008, "Wrong alignment on PhxAICharacter_GetOffensiveActionsComponent");
static_assert(sizeof(PhxAICharacter_GetOffensiveActionsComponent) == 0x000008, "Wrong size on PhxAICharacter_GetOffensiveActionsComponent");
static_assert(offsetof(PhxAICharacter_GetOffensiveActionsComponent, ReturnValue) == 0x000000, "Member 'PhxAICharacter_GetOffensiveActionsComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.ActivateCameraState
// 0x0038 (0x0038 - 0x0000)
struct PhxGameplayStatics_ActivateCameraState final
{
public:
	struct FCameraGraphEntrySelector              TargetCamera;                                      // 0x0000(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          Enabled;                                           // 0x0030(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_ActivateCameraState) == 0x000008, "Wrong alignment on PhxGameplayStatics_ActivateCameraState");
static_assert(sizeof(PhxGameplayStatics_ActivateCameraState) == 0x000038, "Wrong size on PhxGameplayStatics_ActivateCameraState");
static_assert(offsetof(PhxGameplayStatics_ActivateCameraState, TargetCamera) == 0x000000, "Member 'PhxGameplayStatics_ActivateCameraState::TargetCamera' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_ActivateCameraState, Enabled) == 0x000030, "Member 'PhxGameplayStatics_ActivateCameraState::Enabled' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.AddStreamingViewSlaveLocation
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_AddStreamingViewSlaveLocation final
{
public:
	struct FVector                                SlaveLocation;                                     // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BoostFactor;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bOverrideLocation;                                 // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x3];                                       // 0x0011(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Duration;                                          // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_AddStreamingViewSlaveLocation) == 0x000004, "Wrong alignment on PhxGameplayStatics_AddStreamingViewSlaveLocation");
static_assert(sizeof(PhxGameplayStatics_AddStreamingViewSlaveLocation) == 0x000018, "Wrong size on PhxGameplayStatics_AddStreamingViewSlaveLocation");
static_assert(offsetof(PhxGameplayStatics_AddStreamingViewSlaveLocation, SlaveLocation) == 0x000000, "Member 'PhxGameplayStatics_AddStreamingViewSlaveLocation::SlaveLocation' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_AddStreamingViewSlaveLocation, BoostFactor) == 0x00000C, "Member 'PhxGameplayStatics_AddStreamingViewSlaveLocation::BoostFactor' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_AddStreamingViewSlaveLocation, bOverrideLocation) == 0x000010, "Member 'PhxGameplayStatics_AddStreamingViewSlaveLocation::bOverrideLocation' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_AddStreamingViewSlaveLocation, Duration) == 0x000014, "Member 'PhxGameplayStatics_AddStreamingViewSlaveLocation::Duration' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.CheckCapsuleToCapsuleCollision
// 0x0044 (0x0044 - 0x0000)
struct PhxGameplayStatics_CheckCapsuleToCapsuleCollision final
{
public:
	struct FVector                                CapsuleALocation;                                  // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CapsuleARadius;                                    // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CapsuleAHalfHeight;                                // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                CapsuleAUpVector;                                  // 0x0014(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                CapsuleBLocation;                                  // 0x0020(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CapsuleBRadius;                                    // 0x002C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CapsuleBHalfHeight;                                // 0x0030(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                CapsuleBUpVector;                                  // 0x0034(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0040(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_41[0x3];                                       // 0x0041(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision) == 0x000004, "Wrong alignment on PhxGameplayStatics_CheckCapsuleToCapsuleCollision");
static_assert(sizeof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision) == 0x000044, "Wrong size on PhxGameplayStatics_CheckCapsuleToCapsuleCollision");
static_assert(offsetof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision, CapsuleALocation) == 0x000000, "Member 'PhxGameplayStatics_CheckCapsuleToCapsuleCollision::CapsuleALocation' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision, CapsuleARadius) == 0x00000C, "Member 'PhxGameplayStatics_CheckCapsuleToCapsuleCollision::CapsuleARadius' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision, CapsuleAHalfHeight) == 0x000010, "Member 'PhxGameplayStatics_CheckCapsuleToCapsuleCollision::CapsuleAHalfHeight' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision, CapsuleAUpVector) == 0x000014, "Member 'PhxGameplayStatics_CheckCapsuleToCapsuleCollision::CapsuleAUpVector' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision, CapsuleBLocation) == 0x000020, "Member 'PhxGameplayStatics_CheckCapsuleToCapsuleCollision::CapsuleBLocation' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision, CapsuleBRadius) == 0x00002C, "Member 'PhxGameplayStatics_CheckCapsuleToCapsuleCollision::CapsuleBRadius' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision, CapsuleBHalfHeight) == 0x000030, "Member 'PhxGameplayStatics_CheckCapsuleToCapsuleCollision::CapsuleBHalfHeight' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision, CapsuleBUpVector) == 0x000034, "Member 'PhxGameplayStatics_CheckCapsuleToCapsuleCollision::CapsuleBUpVector' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_CheckCapsuleToCapsuleCollision, ReturnValue) == 0x000040, "Member 'PhxGameplayStatics_CheckCapsuleToCapsuleCollision::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.ClearEntitlementCache
// 0x0004 (0x0004 - 0x0000)
struct PhxGameplayStatics_ClearEntitlementCache final
{
public:
	int32                                         UserNum;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_ClearEntitlementCache) == 0x000004, "Wrong alignment on PhxGameplayStatics_ClearEntitlementCache");
static_assert(sizeof(PhxGameplayStatics_ClearEntitlementCache) == 0x000004, "Wrong size on PhxGameplayStatics_ClearEntitlementCache");
static_assert(offsetof(PhxGameplayStatics_ClearEntitlementCache, UserNum) == 0x000000, "Member 'PhxGameplayStatics_ClearEntitlementCache::UserNum' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.ConvertMayaRotationToUnrealSpace
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_ConvertMayaRotationToUnrealSpace final
{
public:
	struct FRotator                               MayaRot;                                           // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FRotator                               ReturnValue;                                       // 0x000C(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_ConvertMayaRotationToUnrealSpace) == 0x000004, "Wrong alignment on PhxGameplayStatics_ConvertMayaRotationToUnrealSpace");
static_assert(sizeof(PhxGameplayStatics_ConvertMayaRotationToUnrealSpace) == 0x000018, "Wrong size on PhxGameplayStatics_ConvertMayaRotationToUnrealSpace");
static_assert(offsetof(PhxGameplayStatics_ConvertMayaRotationToUnrealSpace, MayaRot) == 0x000000, "Member 'PhxGameplayStatics_ConvertMayaRotationToUnrealSpace::MayaRot' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_ConvertMayaRotationToUnrealSpace, ReturnValue) == 0x00000C, "Member 'PhxGameplayStatics_ConvertMayaRotationToUnrealSpace::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.ExecuteGameplayCondition
// 0x0020 (0x0020 - 0x0000)
struct PhxGameplayStatics_ExecuteGameplayCondition final
{
public:
	struct FPhxGameplayConditionContainer         ConditionContainer;                                // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FGameplayConditionContext              ConditionContext;                                  // 0x0008(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_ExecuteGameplayCondition) == 0x000008, "Wrong alignment on PhxGameplayStatics_ExecuteGameplayCondition");
static_assert(sizeof(PhxGameplayStatics_ExecuteGameplayCondition) == 0x000020, "Wrong size on PhxGameplayStatics_ExecuteGameplayCondition");
static_assert(offsetof(PhxGameplayStatics_ExecuteGameplayCondition, ConditionContainer) == 0x000000, "Member 'PhxGameplayStatics_ExecuteGameplayCondition::ConditionContainer' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_ExecuteGameplayCondition, ConditionContext) == 0x000008, "Member 'PhxGameplayStatics_ExecuteGameplayCondition::ConditionContext' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_ExecuteGameplayCondition, ReturnValue) == 0x000018, "Member 'PhxGameplayStatics_ExecuteGameplayCondition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.ForcePlayerOntoTraversalSpline
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_ForcePlayerOntoTraversalSpline final
{
public:
	class APhxPlayerCharacter*                    InPlayerCharacter;                                 // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxTraversalSpline*                    InTraversalSpline;                                 // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_ForcePlayerOntoTraversalSpline) == 0x000008, "Wrong alignment on PhxGameplayStatics_ForcePlayerOntoTraversalSpline");
static_assert(sizeof(PhxGameplayStatics_ForcePlayerOntoTraversalSpline) == 0x000010, "Wrong size on PhxGameplayStatics_ForcePlayerOntoTraversalSpline");
static_assert(offsetof(PhxGameplayStatics_ForcePlayerOntoTraversalSpline, InPlayerCharacter) == 0x000000, "Member 'PhxGameplayStatics_ForcePlayerOntoTraversalSpline::InPlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_ForcePlayerOntoTraversalSpline, InTraversalSpline) == 0x000008, "Member 'PhxGameplayStatics_ForcePlayerOntoTraversalSpline::InTraversalSpline' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetAnimCurveValueAtTime
// 0x0028 (0x0028 - 0x0000)
struct PhxGameplayStatics_GetAnimCurveValueAtTime final
{
public:
	class UAnimSequenceBase*                      Sequence;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USkeletalMeshComponent*                 SkelMesh;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   CurveName;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Time;                                              // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OutCurveValue;                                     // 0x001C(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0020(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x7];                                       // 0x0021(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_GetAnimCurveValueAtTime) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetAnimCurveValueAtTime");
static_assert(sizeof(PhxGameplayStatics_GetAnimCurveValueAtTime) == 0x000028, "Wrong size on PhxGameplayStatics_GetAnimCurveValueAtTime");
static_assert(offsetof(PhxGameplayStatics_GetAnimCurveValueAtTime, Sequence) == 0x000000, "Member 'PhxGameplayStatics_GetAnimCurveValueAtTime::Sequence' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetAnimCurveValueAtTime, SkelMesh) == 0x000008, "Member 'PhxGameplayStatics_GetAnimCurveValueAtTime::SkelMesh' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetAnimCurveValueAtTime, CurveName) == 0x000010, "Member 'PhxGameplayStatics_GetAnimCurveValueAtTime::CurveName' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetAnimCurveValueAtTime, Time) == 0x000018, "Member 'PhxGameplayStatics_GetAnimCurveValueAtTime::Time' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetAnimCurveValueAtTime, OutCurveValue) == 0x00001C, "Member 'PhxGameplayStatics_GetAnimCurveValueAtTime::OutCurveValue' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetAnimCurveValueAtTime, ReturnValue) == 0x000020, "Member 'PhxGameplayStatics_GetAnimCurveValueAtTime::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetAnimMontageCurrentTime
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_GetAnimMontageCurrentTime final
{
public:
	class UAnimMontage*                           Montage;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USkeletalMeshComponent*                 SkelMesh;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OutTime;                                           // 0x0010(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0014(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15[0x3];                                       // 0x0015(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_GetAnimMontageCurrentTime) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetAnimMontageCurrentTime");
static_assert(sizeof(PhxGameplayStatics_GetAnimMontageCurrentTime) == 0x000018, "Wrong size on PhxGameplayStatics_GetAnimMontageCurrentTime");
static_assert(offsetof(PhxGameplayStatics_GetAnimMontageCurrentTime, Montage) == 0x000000, "Member 'PhxGameplayStatics_GetAnimMontageCurrentTime::Montage' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetAnimMontageCurrentTime, SkelMesh) == 0x000008, "Member 'PhxGameplayStatics_GetAnimMontageCurrentTime::SkelMesh' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetAnimMontageCurrentTime, OutTime) == 0x000010, "Member 'PhxGameplayStatics_GetAnimMontageCurrentTime::OutTime' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetAnimMontageCurrentTime, ReturnValue) == 0x000014, "Member 'PhxGameplayStatics_GetAnimMontageCurrentTime::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetBoneTransformFromAnimSequenceAtTime
// 0x0050 (0x0050 - 0x0000)
struct PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime final
{
public:
	class USkeletalMeshComponent*                 Mesh;                                              // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequence*                          AnimSequence;                                      // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BoneName;                                          // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Time;                                              // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTransform                             ReturnValue;                                       // 0x0020(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime) == 0x000010, "Wrong alignment on PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime");
static_assert(sizeof(PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime) == 0x000050, "Wrong size on PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime, Mesh) == 0x000000, "Member 'PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime::Mesh' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime, AnimSequence) == 0x000008, "Member 'PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime::AnimSequence' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime, BoneName) == 0x000010, "Member 'PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime::BoneName' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime, Time) == 0x000018, "Member 'PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime::Time' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime, ReturnValue) == 0x000020, "Member 'PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetBoneTransformFromMontageAtTime
// 0x0050 (0x0050 - 0x0000)
struct PhxGameplayStatics_GetBoneTransformFromMontageAtTime final
{
public:
	class USkeletalMeshComponent*                 Mesh;                                              // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimMontage*                           AnimMontage;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BoneName;                                          // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Time;                                              // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         AnimSegmentIndex;                                  // 0x001C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FTransform                             ReturnValue;                                       // 0x0020(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetBoneTransformFromMontageAtTime) == 0x000010, "Wrong alignment on PhxGameplayStatics_GetBoneTransformFromMontageAtTime");
static_assert(sizeof(PhxGameplayStatics_GetBoneTransformFromMontageAtTime) == 0x000050, "Wrong size on PhxGameplayStatics_GetBoneTransformFromMontageAtTime");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromMontageAtTime, Mesh) == 0x000000, "Member 'PhxGameplayStatics_GetBoneTransformFromMontageAtTime::Mesh' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromMontageAtTime, AnimMontage) == 0x000008, "Member 'PhxGameplayStatics_GetBoneTransformFromMontageAtTime::AnimMontage' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromMontageAtTime, BoneName) == 0x000010, "Member 'PhxGameplayStatics_GetBoneTransformFromMontageAtTime::BoneName' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromMontageAtTime, Time) == 0x000018, "Member 'PhxGameplayStatics_GetBoneTransformFromMontageAtTime::Time' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromMontageAtTime, AnimSegmentIndex) == 0x00001C, "Member 'PhxGameplayStatics_GetBoneTransformFromMontageAtTime::AnimSegmentIndex' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetBoneTransformFromMontageAtTime, ReturnValue) == 0x000020, "Member 'PhxGameplayStatics_GetBoneTransformFromMontageAtTime::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetCurrentCheckpointFromProgress
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_GetCurrentCheckpointFromProgress final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ACheckpoint*                            ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetCurrentCheckpointFromProgress) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetCurrentCheckpointFromProgress");
static_assert(sizeof(PhxGameplayStatics_GetCurrentCheckpointFromProgress) == 0x000010, "Wrong size on PhxGameplayStatics_GetCurrentCheckpointFromProgress");
static_assert(offsetof(PhxGameplayStatics_GetCurrentCheckpointFromProgress, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_GetCurrentCheckpointFromProgress::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetCurrentCheckpointFromProgress, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_GetCurrentCheckpointFromProgress::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetCurrentPrinter
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_GetCurrentPrinter final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APrinterV2*                             ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetCurrentPrinter) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetCurrentPrinter");
static_assert(sizeof(PhxGameplayStatics_GetCurrentPrinter) == 0x000010, "Wrong size on PhxGameplayStatics_GetCurrentPrinter");
static_assert(offsetof(PhxGameplayStatics_GetCurrentPrinter, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_GetCurrentPrinter::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetCurrentPrinter, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_GetCurrentPrinter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetLevelScriptActor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_GetLevelScriptActor final
{
public:
	class AActor*                                 Actor;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ALevelScriptActor*                      ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetLevelScriptActor) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetLevelScriptActor");
static_assert(sizeof(PhxGameplayStatics_GetLevelScriptActor) == 0x000010, "Wrong size on PhxGameplayStatics_GetLevelScriptActor");
static_assert(offsetof(PhxGameplayStatics_GetLevelScriptActor, Actor) == 0x000000, "Member 'PhxGameplayStatics_GetLevelScriptActor::Actor' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetLevelScriptActor, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_GetLevelScriptActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetPhxGameMode
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_GetPhxGameMode final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhoenixGameModeBase*                   ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetPhxGameMode) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetPhxGameMode");
static_assert(sizeof(PhxGameplayStatics_GetPhxGameMode) == 0x000010, "Wrong size on PhxGameplayStatics_GetPhxGameMode");
static_assert(offsetof(PhxGameplayStatics_GetPhxGameMode, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_GetPhxGameMode::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetPhxGameMode, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_GetPhxGameMode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetPhxPlayerCharacter
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_GetPhxPlayerCharacter final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PlayerIndex;                                       // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class APhxPlayerCharacter*                    ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetPhxPlayerCharacter) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetPhxPlayerCharacter");
static_assert(sizeof(PhxGameplayStatics_GetPhxPlayerCharacter) == 0x000018, "Wrong size on PhxGameplayStatics_GetPhxPlayerCharacter");
static_assert(offsetof(PhxGameplayStatics_GetPhxPlayerCharacter, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_GetPhxPlayerCharacter::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetPhxPlayerCharacter, PlayerIndex) == 0x000008, "Member 'PhxGameplayStatics_GetPhxPlayerCharacter::PlayerIndex' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetPhxPlayerCharacter, ReturnValue) == 0x000010, "Member 'PhxGameplayStatics_GetPhxPlayerCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetPhxSoundComponent
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_GetPhxSoundComponent final
{
public:
	class USceneComponent*                        AttachToComponent;                                 // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   AttachPointName;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxSoundComponent*                     ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetPhxSoundComponent) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetPhxSoundComponent");
static_assert(sizeof(PhxGameplayStatics_GetPhxSoundComponent) == 0x000018, "Wrong size on PhxGameplayStatics_GetPhxSoundComponent");
static_assert(offsetof(PhxGameplayStatics_GetPhxSoundComponent, AttachToComponent) == 0x000000, "Member 'PhxGameplayStatics_GetPhxSoundComponent::AttachToComponent' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetPhxSoundComponent, AttachPointName) == 0x000008, "Member 'PhxGameplayStatics_GetPhxSoundComponent::AttachPointName' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetPhxSoundComponent, ReturnValue) == 0x000010, "Member 'PhxGameplayStatics_GetPhxSoundComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetPlayerInventory
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_GetPlayerInventory final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxCharacterInventoryComponent*        ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetPlayerInventory) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetPlayerInventory");
static_assert(sizeof(PhxGameplayStatics_GetPlayerInventory) == 0x000010, "Wrong size on PhxGameplayStatics_GetPlayerInventory");
static_assert(offsetof(PhxGameplayStatics_GetPlayerInventory, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_GetPlayerInventory::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetPlayerInventory, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_GetPlayerInventory::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetTerritoryReleaseSettings
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayStatics_GetTerritoryReleaseSettings final
{
public:
	struct FPhxTerritoryReleaseSettings           ReturnValue;                                       // 0x0000(0x0001)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetTerritoryReleaseSettings) == 0x000001, "Wrong alignment on PhxGameplayStatics_GetTerritoryReleaseSettings");
static_assert(sizeof(PhxGameplayStatics_GetTerritoryReleaseSettings) == 0x000001, "Wrong size on PhxGameplayStatics_GetTerritoryReleaseSettings");
static_assert(offsetof(PhxGameplayStatics_GetTerritoryReleaseSettings, ReturnValue) == 0x000000, "Member 'PhxGameplayStatics_GetTerritoryReleaseSettings::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetUIComponent
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_GetUIComponent final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxPlayerControllerUIComponent*        ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetUIComponent) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetUIComponent");
static_assert(sizeof(PhxGameplayStatics_GetUIComponent) == 0x000010, "Wrong size on PhxGameplayStatics_GetUIComponent");
static_assert(offsetof(PhxGameplayStatics_GetUIComponent, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_GetUIComponent::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetUIComponent, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_GetUIComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.GetUISystem
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_GetUISystem final
{
public:
	class APlayerController*                      PlayerController;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USDSUISystem*                           ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_GetUISystem) == 0x000008, "Wrong alignment on PhxGameplayStatics_GetUISystem");
static_assert(sizeof(PhxGameplayStatics_GetUISystem) == 0x000010, "Wrong size on PhxGameplayStatics_GetUISystem");
static_assert(offsetof(PhxGameplayStatics_GetUISystem, PlayerController) == 0x000000, "Member 'PhxGameplayStatics_GetUISystem::PlayerController' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_GetUISystem, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_GetUISystem::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.HasGateExecuted
// 0x0020 (0x0020 - 0x0000)
struct PhxGameplayStatics_HasGateExecuted final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 GateId;                                            // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_HasGateExecuted) == 0x000008, "Wrong alignment on PhxGameplayStatics_HasGateExecuted");
static_assert(sizeof(PhxGameplayStatics_HasGateExecuted) == 0x000020, "Wrong size on PhxGameplayStatics_HasGateExecuted");
static_assert(offsetof(PhxGameplayStatics_HasGateExecuted, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_HasGateExecuted::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_HasGateExecuted, GateId) == 0x000008, "Member 'PhxGameplayStatics_HasGateExecuted::GateId' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_HasGateExecuted, ReturnValue) == 0x000018, "Member 'PhxGameplayStatics_HasGateExecuted::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.InstantEquipWeapon
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_InstantEquipWeapon final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class AWeapon>                    WeaponClass;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowNotification;                                 // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_InstantEquipWeapon) == 0x000008, "Wrong alignment on PhxGameplayStatics_InstantEquipWeapon");
static_assert(sizeof(PhxGameplayStatics_InstantEquipWeapon) == 0x000018, "Wrong size on PhxGameplayStatics_InstantEquipWeapon");
static_assert(offsetof(PhxGameplayStatics_InstantEquipWeapon, Character) == 0x000000, "Member 'PhxGameplayStatics_InstantEquipWeapon::Character' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_InstantEquipWeapon, WeaponClass) == 0x000008, "Member 'PhxGameplayStatics_InstantEquipWeapon::WeaponClass' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_InstantEquipWeapon, bShowNotification) == 0x000010, "Member 'PhxGameplayStatics_InstantEquipWeapon::bShowNotification' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsConsole
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_IsConsole final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_IsConsole) == 0x000008, "Wrong alignment on PhxGameplayStatics_IsConsole");
static_assert(sizeof(PhxGameplayStatics_IsConsole) == 0x000010, "Wrong size on PhxGameplayStatics_IsConsole");
static_assert(offsetof(PhxGameplayStatics_IsConsole, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_IsConsole::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_IsConsole, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_IsConsole::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsDemoMode
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayStatics_IsDemoMode final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_IsDemoMode) == 0x000001, "Wrong alignment on PhxGameplayStatics_IsDemoMode");
static_assert(sizeof(PhxGameplayStatics_IsDemoMode) == 0x000001, "Wrong size on PhxGameplayStatics_IsDemoMode");
static_assert(offsetof(PhxGameplayStatics_IsDemoMode, ReturnValue) == 0x000000, "Member 'PhxGameplayStatics_IsDemoMode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsGameplayMap
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_IsGameplayMap final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_IsGameplayMap) == 0x000008, "Wrong alignment on PhxGameplayStatics_IsGameplayMap");
static_assert(sizeof(PhxGameplayStatics_IsGameplayMap) == 0x000010, "Wrong size on PhxGameplayStatics_IsGameplayMap");
static_assert(offsetof(PhxGameplayStatics_IsGameplayMap, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_IsGameplayMap::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_IsGameplayMap, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_IsGameplayMap::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsHealthBarRequired
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_IsHealthBarRequired final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_IsHealthBarRequired) == 0x000008, "Wrong alignment on PhxGameplayStatics_IsHealthBarRequired");
static_assert(sizeof(PhxGameplayStatics_IsHealthBarRequired) == 0x000010, "Wrong size on PhxGameplayStatics_IsHealthBarRequired");
static_assert(offsetof(PhxGameplayStatics_IsHealthBarRequired, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_IsHealthBarRequired::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_IsHealthBarRequired, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_IsHealthBarRequired::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsHitReactionValid
// 0x0070 (0x0070 - 0x0000)
struct PhxGameplayStatics_IsHitReactionValid final
{
public:
	struct FHitReactionData                       HitReactionData;                                   // 0x0000(0x0068)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0068(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_69[0x7];                                       // 0x0069(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_IsHitReactionValid) == 0x000008, "Wrong alignment on PhxGameplayStatics_IsHitReactionValid");
static_assert(sizeof(PhxGameplayStatics_IsHitReactionValid) == 0x000070, "Wrong size on PhxGameplayStatics_IsHitReactionValid");
static_assert(offsetof(PhxGameplayStatics_IsHitReactionValid, HitReactionData) == 0x000000, "Member 'PhxGameplayStatics_IsHitReactionValid::HitReactionData' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_IsHitReactionValid, ReturnValue) == 0x000068, "Member 'PhxGameplayStatics_IsHitReactionValid::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsInMenus
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_IsInMenus final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_IsInMenus) == 0x000008, "Wrong alignment on PhxGameplayStatics_IsInMenus");
static_assert(sizeof(PhxGameplayStatics_IsInMenus) == 0x000010, "Wrong size on PhxGameplayStatics_IsInMenus");
static_assert(offsetof(PhxGameplayStatics_IsInMenus, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_IsInMenus::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_IsInMenus, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_IsInMenus::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsIntroMap
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_IsIntroMap final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_IsIntroMap) == 0x000008, "Wrong alignment on PhxGameplayStatics_IsIntroMap");
static_assert(sizeof(PhxGameplayStatics_IsIntroMap) == 0x000010, "Wrong size on PhxGameplayStatics_IsIntroMap");
static_assert(offsetof(PhxGameplayStatics_IsIntroMap, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_IsIntroMap::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_IsIntroMap, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_IsIntroMap::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsLocationOnScreen
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_IsLocationOnScreen final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                WorldLocation;                                     // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0014(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15[0x3];                                       // 0x0015(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_IsLocationOnScreen) == 0x000008, "Wrong alignment on PhxGameplayStatics_IsLocationOnScreen");
static_assert(sizeof(PhxGameplayStatics_IsLocationOnScreen) == 0x000018, "Wrong size on PhxGameplayStatics_IsLocationOnScreen");
static_assert(offsetof(PhxGameplayStatics_IsLocationOnScreen, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_IsLocationOnScreen::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_IsLocationOnScreen, WorldLocation) == 0x000008, "Member 'PhxGameplayStatics_IsLocationOnScreen::WorldLocation' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_IsLocationOnScreen, ReturnValue) == 0x000014, "Member 'PhxGameplayStatics_IsLocationOnScreen::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsLowEndStreamingPlatform
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayStatics_IsLowEndStreamingPlatform final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_IsLowEndStreamingPlatform) == 0x000001, "Wrong alignment on PhxGameplayStatics_IsLowEndStreamingPlatform");
static_assert(sizeof(PhxGameplayStatics_IsLowEndStreamingPlatform) == 0x000001, "Wrong size on PhxGameplayStatics_IsLowEndStreamingPlatform");
static_assert(offsetof(PhxGameplayStatics_IsLowEndStreamingPlatform, ReturnValue) == 0x000000, "Member 'PhxGameplayStatics_IsLowEndStreamingPlatform::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsMiddleEndPlatform
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayStatics_IsMiddleEndPlatform final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_IsMiddleEndPlatform) == 0x000001, "Wrong alignment on PhxGameplayStatics_IsMiddleEndPlatform");
static_assert(sizeof(PhxGameplayStatics_IsMiddleEndPlatform) == 0x000001, "Wrong size on PhxGameplayStatics_IsMiddleEndPlatform");
static_assert(offsetof(PhxGameplayStatics_IsMiddleEndPlatform, ReturnValue) == 0x000000, "Member 'PhxGameplayStatics_IsMiddleEndPlatform::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsOnline
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayStatics_IsOnline final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_IsOnline) == 0x000001, "Wrong alignment on PhxGameplayStatics_IsOnline");
static_assert(sizeof(PhxGameplayStatics_IsOnline) == 0x000001, "Wrong size on PhxGameplayStatics_IsOnline");
static_assert(offsetof(PhxGameplayStatics_IsOnline, ReturnValue) == 0x000000, "Member 'PhxGameplayStatics_IsOnline::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsOutroMap
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_IsOutroMap final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_IsOutroMap) == 0x000008, "Wrong alignment on PhxGameplayStatics_IsOutroMap");
static_assert(sizeof(PhxGameplayStatics_IsOutroMap) == 0x000010, "Wrong size on PhxGameplayStatics_IsOutroMap");
static_assert(offsetof(PhxGameplayStatics_IsOutroMap, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_IsOutroMap::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_IsOutroMap, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_IsOutroMap::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsReducedGoreEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayStatics_IsReducedGoreEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_IsReducedGoreEnabled) == 0x000001, "Wrong alignment on PhxGameplayStatics_IsReducedGoreEnabled");
static_assert(sizeof(PhxGameplayStatics_IsReducedGoreEnabled) == 0x000001, "Wrong size on PhxGameplayStatics_IsReducedGoreEnabled");
static_assert(offsetof(PhxGameplayStatics_IsReducedGoreEnabled, ReturnValue) == 0x000000, "Member 'PhxGameplayStatics_IsReducedGoreEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsShippingBuild
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayStatics_IsShippingBuild final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_IsShippingBuild) == 0x000001, "Wrong alignment on PhxGameplayStatics_IsShippingBuild");
static_assert(sizeof(PhxGameplayStatics_IsShippingBuild) == 0x000001, "Wrong size on PhxGameplayStatics_IsShippingBuild");
static_assert(offsetof(PhxGameplayStatics_IsShippingBuild, ReturnValue) == 0x000000, "Member 'PhxGameplayStatics_IsShippingBuild::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.IsStoreFrontEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayStatics_IsStoreFrontEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_IsStoreFrontEnabled) == 0x000001, "Wrong alignment on PhxGameplayStatics_IsStoreFrontEnabled");
static_assert(sizeof(PhxGameplayStatics_IsStoreFrontEnabled) == 0x000001, "Wrong size on PhxGameplayStatics_IsStoreFrontEnabled");
static_assert(offsetof(PhxGameplayStatics_IsStoreFrontEnabled, ReturnValue) == 0x000000, "Member 'PhxGameplayStatics_IsStoreFrontEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PhxCheckDoneForDoOnceGate
// 0x0020 (0x0020 - 0x0000)
struct PhxGameplayStatics_PhxCheckDoneForDoOnceGate final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Key;                                               // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDone;                                             // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxDoOnceCheckDonePath                       Path;                                              // 0x0019(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1A[0x6];                                       // 0x001A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_PhxCheckDoneForDoOnceGate) == 0x000008, "Wrong alignment on PhxGameplayStatics_PhxCheckDoneForDoOnceGate");
static_assert(sizeof(PhxGameplayStatics_PhxCheckDoneForDoOnceGate) == 0x000020, "Wrong size on PhxGameplayStatics_PhxCheckDoneForDoOnceGate");
static_assert(offsetof(PhxGameplayStatics_PhxCheckDoneForDoOnceGate, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_PhxCheckDoneForDoOnceGate::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxCheckDoneForDoOnceGate, Key) == 0x000008, "Member 'PhxGameplayStatics_PhxCheckDoneForDoOnceGate::Key' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxCheckDoneForDoOnceGate, bDone) == 0x000018, "Member 'PhxGameplayStatics_PhxCheckDoneForDoOnceGate::bDone' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxCheckDoneForDoOnceGate, Path) == 0x000019, "Member 'PhxGameplayStatics_PhxCheckDoneForDoOnceGate::Path' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PhxGetLevelScriptActor
// 0x0030 (0x0030 - 0x0000)
struct PhxGameplayStatics_PhxGetLevelScriptActor final
{
public:
	TSoftObjectPtr<class UWorld>                  SubLevel;                                          // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ALevelScriptActor*                      ReturnValue;                                       // 0x0028(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PhxGetLevelScriptActor) == 0x000008, "Wrong alignment on PhxGameplayStatics_PhxGetLevelScriptActor");
static_assert(sizeof(PhxGameplayStatics_PhxGetLevelScriptActor) == 0x000030, "Wrong size on PhxGameplayStatics_PhxGetLevelScriptActor");
static_assert(offsetof(PhxGameplayStatics_PhxGetLevelScriptActor, SubLevel) == 0x000000, "Member 'PhxGameplayStatics_PhxGetLevelScriptActor::SubLevel' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxGetLevelScriptActor, ReturnValue) == 0x000028, "Member 'PhxGameplayStatics_PhxGetLevelScriptActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PhxLoadSharedStreamLevel
// 0x0050 (0x0050 - 0x0000)
struct PhxGameplayStatics_PhxLoadSharedStreamLevel final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UWorld>                  Level;                                             // 0x0008(0x0028)(ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMakeVisibleAfterLoad;                             // 0x0030(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShouldBlockOnLoad;                                // 0x0031(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_32[0x6];                                       // 0x0032(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FLatentActionInfo                      LatentInfo;                                        // 0x0038(0x0018)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PhxLoadSharedStreamLevel) == 0x000008, "Wrong alignment on PhxGameplayStatics_PhxLoadSharedStreamLevel");
static_assert(sizeof(PhxGameplayStatics_PhxLoadSharedStreamLevel) == 0x000050, "Wrong size on PhxGameplayStatics_PhxLoadSharedStreamLevel");
static_assert(offsetof(PhxGameplayStatics_PhxLoadSharedStreamLevel, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_PhxLoadSharedStreamLevel::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxLoadSharedStreamLevel, Level) == 0x000008, "Member 'PhxGameplayStatics_PhxLoadSharedStreamLevel::Level' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxLoadSharedStreamLevel, bMakeVisibleAfterLoad) == 0x000030, "Member 'PhxGameplayStatics_PhxLoadSharedStreamLevel::bMakeVisibleAfterLoad' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxLoadSharedStreamLevel, bShouldBlockOnLoad) == 0x000031, "Member 'PhxGameplayStatics_PhxLoadSharedStreamLevel::bShouldBlockOnLoad' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxLoadSharedStreamLevel, LatentInfo) == 0x000038, "Member 'PhxGameplayStatics_PhxLoadSharedStreamLevel::LatentInfo' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PhxPlayMedia
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_PhxPlayMedia final
{
public:
	class UMediaPlayer*                           MediaPlayer;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_PhxPlayMedia) == 0x000008, "Wrong alignment on PhxGameplayStatics_PhxPlayMedia");
static_assert(sizeof(PhxGameplayStatics_PhxPlayMedia) == 0x000010, "Wrong size on PhxGameplayStatics_PhxPlayMedia");
static_assert(offsetof(PhxGameplayStatics_PhxPlayMedia, MediaPlayer) == 0x000000, "Member 'PhxGameplayStatics_PhxPlayMedia::MediaPlayer' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxPlayMedia, ReturnValue) == 0x000008, "Member 'PhxGameplayStatics_PhxPlayMedia::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PhxUnloadSharedStreamLevel
// 0x0050 (0x0050 - 0x0000)
struct PhxGameplayStatics_PhxUnloadSharedStreamLevel final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UWorld>                  Level;                                             // 0x0008(0x0028)(ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLatentActionInfo                      LatentInfo;                                        // 0x0030(0x0018)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bShouldBlockOnUnload;                              // 0x0048(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_PhxUnloadSharedStreamLevel) == 0x000008, "Wrong alignment on PhxGameplayStatics_PhxUnloadSharedStreamLevel");
static_assert(sizeof(PhxGameplayStatics_PhxUnloadSharedStreamLevel) == 0x000050, "Wrong size on PhxGameplayStatics_PhxUnloadSharedStreamLevel");
static_assert(offsetof(PhxGameplayStatics_PhxUnloadSharedStreamLevel, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_PhxUnloadSharedStreamLevel::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxUnloadSharedStreamLevel, Level) == 0x000008, "Member 'PhxGameplayStatics_PhxUnloadSharedStreamLevel::Level' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxUnloadSharedStreamLevel, LatentInfo) == 0x000030, "Member 'PhxGameplayStatics_PhxUnloadSharedStreamLevel::LatentInfo' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PhxUnloadSharedStreamLevel, bShouldBlockOnUnload) == 0x000048, "Member 'PhxGameplayStatics_PhxUnloadSharedStreamLevel::bShouldBlockOnUnload' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PlaceholderVO
// 0x0030 (0x0030 - 0x0000)
struct PhxGameplayStatics_PlaceholderVO final
{
public:
	class AActor*                                 Speaker;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkAudioEvent*                          AkEvent;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Line;                                              // 0x0010(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DisplayTime;                                       // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxSoundComponent*                     OverrideComponent;                                 // 0x0028(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PlaceholderVO) == 0x000008, "Wrong alignment on PhxGameplayStatics_PlaceholderVO");
static_assert(sizeof(PhxGameplayStatics_PlaceholderVO) == 0x000030, "Wrong size on PhxGameplayStatics_PlaceholderVO");
static_assert(offsetof(PhxGameplayStatics_PlaceholderVO, Speaker) == 0x000000, "Member 'PhxGameplayStatics_PlaceholderVO::Speaker' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlaceholderVO, AkEvent) == 0x000008, "Member 'PhxGameplayStatics_PlaceholderVO::AkEvent' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlaceholderVO, Line) == 0x000010, "Member 'PhxGameplayStatics_PlaceholderVO::Line' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlaceholderVO, DisplayTime) == 0x000020, "Member 'PhxGameplayStatics_PlaceholderVO::DisplayTime' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlaceholderVO, OverrideComponent) == 0x000028, "Member 'PhxGameplayStatics_PlaceholderVO::OverrideComponent' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PlaceholderVOSubtitle
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_PlaceholderVOSubtitle final
{
public:
	class AActor*                                 Speaker;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   RowName;                                           // 0x0008(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxSoundComponent*                     OverrideComponent;                                 // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PlaceholderVOSubtitle) == 0x000008, "Wrong alignment on PhxGameplayStatics_PlaceholderVOSubtitle");
static_assert(sizeof(PhxGameplayStatics_PlaceholderVOSubtitle) == 0x000018, "Wrong size on PhxGameplayStatics_PlaceholderVOSubtitle");
static_assert(offsetof(PhxGameplayStatics_PlaceholderVOSubtitle, Speaker) == 0x000000, "Member 'PhxGameplayStatics_PlaceholderVOSubtitle::Speaker' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlaceholderVOSubtitle, RowName) == 0x000008, "Member 'PhxGameplayStatics_PlaceholderVOSubtitle::RowName' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlaceholderVOSubtitle, OverrideComponent) == 0x000010, "Member 'PhxGameplayStatics_PlaceholderVOSubtitle::OverrideComponent' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PlayAdHocCinematicWithPerformers
// 0x00E8 (0x00E8 - 0x0000)
struct PhxGameplayStatics_PlayAdHocCinematicWithPerformers final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        LevelSequenceAsset;                                // 0x0008(0x0018)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TMap<int32, struct FPhxAdHocCinematicPerformerInfo> Performers;                                  // 0x0020(0x0050)(Parm, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class APhxCharacter>           AnchorPeformer;                                    // 0x0070(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMovieSceneSequencePlaybackSettings    PlaybackSettings;                                  // 0x0098(0x0014)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FCameraGraphEntrySelector              GraphEntrySelector;                                // 0x00B0(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAdHocLevelSequenceActor*            ReturnValue;                                       // 0x00E0(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers) == 0x000008, "Wrong alignment on PhxGameplayStatics_PlayAdHocCinematicWithPerformers");
static_assert(sizeof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers) == 0x0000E8, "Wrong size on PhxGameplayStatics_PlayAdHocCinematicWithPerformers");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers, LevelSequenceAsset) == 0x000008, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers::LevelSequenceAsset' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers, Performers) == 0x000020, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers::Performers' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers, AnchorPeformer) == 0x000070, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers::AnchorPeformer' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers, PlaybackSettings) == 0x000098, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers::PlaybackSettings' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers, GraphEntrySelector) == 0x0000B0, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers::GraphEntrySelector' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers, ReturnValue) == 0x0000E0, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PlayAdHocCinematicWithPerformers_NoAnchorPerformer
// 0x00D8 (0x00D8 - 0x0000)
struct PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        LevelSequenceAsset;                                // 0x0008(0x0018)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TMap<int32, struct FPhxAdHocCinematicPerformerInfo> Performers;                                  // 0x0020(0x0050)(Parm, NativeAccessSpecifierPublic)
	struct FVector                                ScriptedNodeLocation;                              // 0x0070(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               ScriptedNodeRotation;                              // 0x007C(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FMovieSceneSequencePlaybackSettings    PlaybackSettings;                                  // 0x0088(0x0014)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_9C[0x4];                                       // 0x009C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FCameraGraphEntrySelector              GraphEntrySelector;                                // 0x00A0(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAdHocLevelSequenceActor*            ReturnValue;                                       // 0x00D0(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer) == 0x000008, "Wrong alignment on PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer");
static_assert(sizeof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer) == 0x0000D8, "Wrong size on PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer, LevelSequenceAsset) == 0x000008, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer::LevelSequenceAsset' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer, Performers) == 0x000020, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer::Performers' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer, ScriptedNodeLocation) == 0x000070, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer::ScriptedNodeLocation' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer, ScriptedNodeRotation) == 0x00007C, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer::ScriptedNodeRotation' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer, PlaybackSettings) == 0x000088, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer::PlaybackSettings' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer, GraphEntrySelector) == 0x0000A0, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer::GraphEntrySelector' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer, ReturnValue) == 0x0000D0, "Member 'PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PlayerReachedCheckpoint
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_PlayerReachedCheckpoint final
{
public:
	class APhxCharacter*                          PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Checkpoint;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PlayerReachedCheckpoint) == 0x000008, "Wrong alignment on PhxGameplayStatics_PlayerReachedCheckpoint");
static_assert(sizeof(PhxGameplayStatics_PlayerReachedCheckpoint) == 0x000010, "Wrong size on PhxGameplayStatics_PlayerReachedCheckpoint");
static_assert(offsetof(PhxGameplayStatics_PlayerReachedCheckpoint, PlayerCharacter) == 0x000000, "Member 'PhxGameplayStatics_PlayerReachedCheckpoint::PlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PlayerReachedCheckpoint, Checkpoint) == 0x000008, "Member 'PhxGameplayStatics_PlayerReachedCheckpoint::Checkpoint' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PopCinematicCameras
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayStatics_PopCinematicCameras final
{
public:
	class APhxCharacter*                          PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PopCinematicCameras) == 0x000008, "Wrong alignment on PhxGameplayStatics_PopCinematicCameras");
static_assert(sizeof(PhxGameplayStatics_PopCinematicCameras) == 0x000008, "Wrong size on PhxGameplayStatics_PopCinematicCameras");
static_assert(offsetof(PhxGameplayStatics_PopCinematicCameras, PlayerCharacter) == 0x000000, "Member 'PhxGameplayStatics_PopCinematicCameras::PlayerCharacter' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PopDynamicCameraState
// 0x0068 (0x0068 - 0x0000)
struct PhxGameplayStatics_PopDynamicCameraState final
{
public:
	class APawn*                                  PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCameraGraphEntrySelector              ExternalCamera;                                    // 0x0008(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCameraGraphEntrySelector              TargetParent;                                      // 0x0038(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PopDynamicCameraState) == 0x000008, "Wrong alignment on PhxGameplayStatics_PopDynamicCameraState");
static_assert(sizeof(PhxGameplayStatics_PopDynamicCameraState) == 0x000068, "Wrong size on PhxGameplayStatics_PopDynamicCameraState");
static_assert(offsetof(PhxGameplayStatics_PopDynamicCameraState, PlayerCharacter) == 0x000000, "Member 'PhxGameplayStatics_PopDynamicCameraState::PlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PopDynamicCameraState, ExternalCamera) == 0x000008, "Member 'PhxGameplayStatics_PopDynamicCameraState::ExternalCamera' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PopDynamicCameraState, TargetParent) == 0x000038, "Member 'PhxGameplayStatics_PopDynamicCameraState::TargetParent' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PopExternalCinematicCamera
// 0x0068 (0x0068 - 0x0000)
struct PhxGameplayStatics_PopExternalCinematicCamera final
{
public:
	class APawn*                                  PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCameraGraphEntrySelector              ExternalCamera;                                    // 0x0008(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCameraGraphEntrySelector              TargetParent;                                      // 0x0038(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PopExternalCinematicCamera) == 0x000008, "Wrong alignment on PhxGameplayStatics_PopExternalCinematicCamera");
static_assert(sizeof(PhxGameplayStatics_PopExternalCinematicCamera) == 0x000068, "Wrong size on PhxGameplayStatics_PopExternalCinematicCamera");
static_assert(offsetof(PhxGameplayStatics_PopExternalCinematicCamera, PlayerCharacter) == 0x000000, "Member 'PhxGameplayStatics_PopExternalCinematicCamera::PlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PopExternalCinematicCamera, ExternalCamera) == 0x000008, "Member 'PhxGameplayStatics_PopExternalCinematicCamera::ExternalCamera' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PopExternalCinematicCamera, TargetParent) == 0x000038, "Member 'PhxGameplayStatics_PopExternalCinematicCamera::TargetParent' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PushDynamicCameraState
// 0x0068 (0x0068 - 0x0000)
struct PhxGameplayStatics_PushDynamicCameraState final
{
public:
	class APawn*                                  PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCameraGraphEntrySelector              ExternalCamera;                                    // 0x0008(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCameraGraphEntrySelector              TargetParent;                                      // 0x0038(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PushDynamicCameraState) == 0x000008, "Wrong alignment on PhxGameplayStatics_PushDynamicCameraState");
static_assert(sizeof(PhxGameplayStatics_PushDynamicCameraState) == 0x000068, "Wrong size on PhxGameplayStatics_PushDynamicCameraState");
static_assert(offsetof(PhxGameplayStatics_PushDynamicCameraState, PlayerCharacter) == 0x000000, "Member 'PhxGameplayStatics_PushDynamicCameraState::PlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PushDynamicCameraState, ExternalCamera) == 0x000008, "Member 'PhxGameplayStatics_PushDynamicCameraState::ExternalCamera' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PushDynamicCameraState, TargetParent) == 0x000038, "Member 'PhxGameplayStatics_PushDynamicCameraState::TargetParent' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.PushExternalCinematicCamera
// 0x0070 (0x0070 - 0x0000)
struct PhxGameplayStatics_PushExternalCinematicCamera final
{
public:
	class APawn*                                  PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ACameraActor*                           CameraActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCameraGraphEntrySelector              ExternalCamera;                                    // 0x0010(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCameraGraphEntrySelector              TargetParent;                                      // 0x0040(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_PushExternalCinematicCamera) == 0x000008, "Wrong alignment on PhxGameplayStatics_PushExternalCinematicCamera");
static_assert(sizeof(PhxGameplayStatics_PushExternalCinematicCamera) == 0x000070, "Wrong size on PhxGameplayStatics_PushExternalCinematicCamera");
static_assert(offsetof(PhxGameplayStatics_PushExternalCinematicCamera, PlayerCharacter) == 0x000000, "Member 'PhxGameplayStatics_PushExternalCinematicCamera::PlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PushExternalCinematicCamera, CameraActor) == 0x000008, "Member 'PhxGameplayStatics_PushExternalCinematicCamera::CameraActor' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PushExternalCinematicCamera, ExternalCamera) == 0x000010, "Member 'PhxGameplayStatics_PushExternalCinematicCamera::ExternalCamera' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_PushExternalCinematicCamera, TargetParent) == 0x000040, "Member 'PhxGameplayStatics_PushExternalCinematicCamera::TargetParent' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.RequestAnimatedCameraCut
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayStatics_RequestAnimatedCameraCut final
{
public:
	class APhxCharacter*                          PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_RequestAnimatedCameraCut) == 0x000008, "Wrong alignment on PhxGameplayStatics_RequestAnimatedCameraCut");
static_assert(sizeof(PhxGameplayStatics_RequestAnimatedCameraCut) == 0x000008, "Wrong size on PhxGameplayStatics_RequestAnimatedCameraCut");
static_assert(offsetof(PhxGameplayStatics_RequestAnimatedCameraCut, PlayerCharacter) == 0x000000, "Member 'PhxGameplayStatics_RequestAnimatedCameraCut::PlayerCharacter' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.ResetContagionNoDeathAchievement
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayStatics_ResetContagionNoDeathAchievement final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_ResetContagionNoDeathAchievement) == 0x000008, "Wrong alignment on PhxGameplayStatics_ResetContagionNoDeathAchievement");
static_assert(sizeof(PhxGameplayStatics_ResetContagionNoDeathAchievement) == 0x000008, "Wrong size on PhxGameplayStatics_ResetContagionNoDeathAchievement");
static_assert(offsetof(PhxGameplayStatics_ResetContagionNoDeathAchievement, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_ResetContagionNoDeathAchievement::WorldContextObject' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.SetCharacterLoadout
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_SetCharacterLoadout final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ULoadoutDataAsset*                      LoadoutData;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_SetCharacterLoadout) == 0x000008, "Wrong alignment on PhxGameplayStatics_SetCharacterLoadout");
static_assert(sizeof(PhxGameplayStatics_SetCharacterLoadout) == 0x000010, "Wrong size on PhxGameplayStatics_SetCharacterLoadout");
static_assert(offsetof(PhxGameplayStatics_SetCharacterLoadout, Character) == 0x000000, "Member 'PhxGameplayStatics_SetCharacterLoadout::Character' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SetCharacterLoadout, LoadoutData) == 0x000008, "Member 'PhxGameplayStatics_SetCharacterLoadout::LoadoutData' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.SetLevelSequenceSubSceneActive
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_SetLevelSequenceSubSceneActive final
{
public:
	class ULevelSequence*                         MasterLevelSequence;                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ULevelSequence*                         SubSequence;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bActive;                                           // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_SetLevelSequenceSubSceneActive) == 0x000008, "Wrong alignment on PhxGameplayStatics_SetLevelSequenceSubSceneActive");
static_assert(sizeof(PhxGameplayStatics_SetLevelSequenceSubSceneActive) == 0x000018, "Wrong size on PhxGameplayStatics_SetLevelSequenceSubSceneActive");
static_assert(offsetof(PhxGameplayStatics_SetLevelSequenceSubSceneActive, MasterLevelSequence) == 0x000000, "Member 'PhxGameplayStatics_SetLevelSequenceSubSceneActive::MasterLevelSequence' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SetLevelSequenceSubSceneActive, SubSequence) == 0x000008, "Member 'PhxGameplayStatics_SetLevelSequenceSubSceneActive::SubSequence' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SetLevelSequenceSubSceneActive, bActive) == 0x000010, "Member 'PhxGameplayStatics_SetLevelSequenceSubSceneActive::bActive' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.SetPauseHordeGame
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_SetPauseHordeGame final
{
public:
	bool                                          bPause;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	const class UObject*                          WorldContextObject;                                // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_SetPauseHordeGame) == 0x000008, "Wrong alignment on PhxGameplayStatics_SetPauseHordeGame");
static_assert(sizeof(PhxGameplayStatics_SetPauseHordeGame) == 0x000010, "Wrong size on PhxGameplayStatics_SetPauseHordeGame");
static_assert(offsetof(PhxGameplayStatics_SetPauseHordeGame, bPause) == 0x000000, "Member 'PhxGameplayStatics_SetPauseHordeGame::bPause' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SetPauseHordeGame, WorldContextObject) == 0x000008, "Member 'PhxGameplayStatics_SetPauseHordeGame::WorldContextObject' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.SweepMontage
// 0x00A8 (0x00A8 - 0x0000)
struct PhxGameplayStatics_SweepMontage final
{
public:
	class UWorld*                                 World;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxCharacter*                          Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimMontage*                           Montage;                                           // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0018(0x0088)(Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	int32                                         Segments;                                          // 0x00A0(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00A4(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A5[0x3];                                       // 0x00A5(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_SweepMontage) == 0x000008, "Wrong alignment on PhxGameplayStatics_SweepMontage");
static_assert(sizeof(PhxGameplayStatics_SweepMontage) == 0x0000A8, "Wrong size on PhxGameplayStatics_SweepMontage");
static_assert(offsetof(PhxGameplayStatics_SweepMontage, World) == 0x000000, "Member 'PhxGameplayStatics_SweepMontage::World' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontage, Character) == 0x000008, "Member 'PhxGameplayStatics_SweepMontage::Character' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontage, Montage) == 0x000010, "Member 'PhxGameplayStatics_SweepMontage::Montage' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontage, Hit) == 0x000018, "Member 'PhxGameplayStatics_SweepMontage::Hit' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontage, Segments) == 0x0000A0, "Member 'PhxGameplayStatics_SweepMontage::Segments' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontage, ReturnValue) == 0x0000A4, "Member 'PhxGameplayStatics_SweepMontage::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.SweepMontageSegment
// 0x00F0 (0x00F0 - 0x0000)
struct PhxGameplayStatics_SweepMontageSegment final
{
public:
	class UWorld*                                 World;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxCharacter*                          Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimMontage*                           Montage;                                           // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0018(0x0088)(Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	float                                         StartTime;                                         // 0x00A0(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         EndTime;                                           // 0x00A4(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A8[0x8];                                       // 0x00A8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTransform                             AccruedTransform;                                  // 0x00B0(0x0030)(Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00E0(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_E1[0xF];                                       // 0x00E1(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_SweepMontageSegment) == 0x000010, "Wrong alignment on PhxGameplayStatics_SweepMontageSegment");
static_assert(sizeof(PhxGameplayStatics_SweepMontageSegment) == 0x0000F0, "Wrong size on PhxGameplayStatics_SweepMontageSegment");
static_assert(offsetof(PhxGameplayStatics_SweepMontageSegment, World) == 0x000000, "Member 'PhxGameplayStatics_SweepMontageSegment::World' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageSegment, Character) == 0x000008, "Member 'PhxGameplayStatics_SweepMontageSegment::Character' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageSegment, Montage) == 0x000010, "Member 'PhxGameplayStatics_SweepMontageSegment::Montage' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageSegment, Hit) == 0x000018, "Member 'PhxGameplayStatics_SweepMontageSegment::Hit' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageSegment, StartTime) == 0x0000A0, "Member 'PhxGameplayStatics_SweepMontageSegment::StartTime' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageSegment, EndTime) == 0x0000A4, "Member 'PhxGameplayStatics_SweepMontageSegment::EndTime' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageSegment, AccruedTransform) == 0x0000B0, "Member 'PhxGameplayStatics_SweepMontageSegment::AccruedTransform' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageSegment, ReturnValue) == 0x0000E0, "Member 'PhxGameplayStatics_SweepMontageSegment::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.SweepMontageWithRot
// 0x00B8 (0x00B8 - 0x0000)
struct PhxGameplayStatics_SweepMontageWithRot final
{
public:
	class UWorld*                                 World;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxCharacter*                          Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimMontage*                           Montage;                                           // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0018(0x0088)(Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRotator                               StartRotOverride;                                  // 0x00A0(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	int32                                         Segments;                                          // 0x00AC(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00B0(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_SweepMontageWithRot) == 0x000008, "Wrong alignment on PhxGameplayStatics_SweepMontageWithRot");
static_assert(sizeof(PhxGameplayStatics_SweepMontageWithRot) == 0x0000B8, "Wrong size on PhxGameplayStatics_SweepMontageWithRot");
static_assert(offsetof(PhxGameplayStatics_SweepMontageWithRot, World) == 0x000000, "Member 'PhxGameplayStatics_SweepMontageWithRot::World' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageWithRot, Character) == 0x000008, "Member 'PhxGameplayStatics_SweepMontageWithRot::Character' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageWithRot, Montage) == 0x000010, "Member 'PhxGameplayStatics_SweepMontageWithRot::Montage' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageWithRot, Hit) == 0x000018, "Member 'PhxGameplayStatics_SweepMontageWithRot::Hit' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageWithRot, StartRotOverride) == 0x0000A0, "Member 'PhxGameplayStatics_SweepMontageWithRot::StartRotOverride' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageWithRot, Segments) == 0x0000AC, "Member 'PhxGameplayStatics_SweepMontageWithRot::Segments' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_SweepMontageWithRot, ReturnValue) == 0x0000B0, "Member 'PhxGameplayStatics_SweepMontageWithRot::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.TeleportCharacter
// 0x0040 (0x0040 - 0x0000)
struct PhxGameplayStatics_TeleportCharacter final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_8[0x8];                                        // 0x0008(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTransform                             Transform;                                         // 0x0010(0x0030)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_TeleportCharacter) == 0x000010, "Wrong alignment on PhxGameplayStatics_TeleportCharacter");
static_assert(sizeof(PhxGameplayStatics_TeleportCharacter) == 0x000040, "Wrong size on PhxGameplayStatics_TeleportCharacter");
static_assert(offsetof(PhxGameplayStatics_TeleportCharacter, Character) == 0x000000, "Member 'PhxGameplayStatics_TeleportCharacter::Character' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_TeleportCharacter, Transform) == 0x000010, "Member 'PhxGameplayStatics_TeleportCharacter::Transform' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.TraceBookmark
// 0x0020 (0x0020 - 0x0000)
struct PhxGameplayStatics_TraceBookmark final
{
public:
	class FString                                 Prefix;                                            // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Message;                                           // 0x0010(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_TraceBookmark) == 0x000008, "Wrong alignment on PhxGameplayStatics_TraceBookmark");
static_assert(sizeof(PhxGameplayStatics_TraceBookmark) == 0x000020, "Wrong size on PhxGameplayStatics_TraceBookmark");
static_assert(offsetof(PhxGameplayStatics_TraceBookmark, Prefix) == 0x000000, "Member 'PhxGameplayStatics_TraceBookmark::Prefix' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_TraceBookmark, Message) == 0x000010, "Member 'PhxGameplayStatics_TraceBookmark::Message' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.TransitionToCamera
// 0x0038 (0x0038 - 0x0000)
struct PhxGameplayStatics_TransitionToCamera final
{
public:
	class APhxCharacter*                          PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCameraGraphEntrySelector              CameraSelector;                                    // 0x0008(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayStatics_TransitionToCamera) == 0x000008, "Wrong alignment on PhxGameplayStatics_TransitionToCamera");
static_assert(sizeof(PhxGameplayStatics_TransitionToCamera) == 0x000038, "Wrong size on PhxGameplayStatics_TransitionToCamera");
static_assert(offsetof(PhxGameplayStatics_TransitionToCamera, PlayerCharacter) == 0x000000, "Member 'PhxGameplayStatics_TransitionToCamera::PlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_TransitionToCamera, CameraSelector) == 0x000008, "Member 'PhxGameplayStatics_TransitionToCamera::CameraSelector' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.TriggerAchievementCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_TriggerAchievementCompleted final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAchievements                              AchievementType;                                   // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_TriggerAchievementCompleted) == 0x000008, "Wrong alignment on PhxGameplayStatics_TriggerAchievementCompleted");
static_assert(sizeof(PhxGameplayStatics_TriggerAchievementCompleted) == 0x000010, "Wrong size on PhxGameplayStatics_TriggerAchievementCompleted");
static_assert(offsetof(PhxGameplayStatics_TriggerAchievementCompleted, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_TriggerAchievementCompleted::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_TriggerAchievementCompleted, AchievementType) == 0x000008, "Member 'PhxGameplayStatics_TriggerAchievementCompleted::AchievementType' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.UpdateAchievement5
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayStatics_UpdateAchievement5 final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAchievement5Rooms                            Achievement5Room;                                  // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_UpdateAchievement5) == 0x000008, "Wrong alignment on PhxGameplayStatics_UpdateAchievement5");
static_assert(sizeof(PhxGameplayStatics_UpdateAchievement5) == 0x000010, "Wrong size on PhxGameplayStatics_UpdateAchievement5");
static_assert(offsetof(PhxGameplayStatics_UpdateAchievement5, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_UpdateAchievement5::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_UpdateAchievement5, Achievement5Room) == 0x000008, "Member 'PhxGameplayStatics_UpdateAchievement5::Achievement5Room' has a wrong offset!");

// Function Phoenix.PhxGameplayStatics.WorldHasTag
// 0x0018 (0x0018 - 0x0000)
struct PhxGameplayStatics_WorldHasTag final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           TagToCheck;                                        // 0x0008(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayStatics_WorldHasTag) == 0x000008, "Wrong alignment on PhxGameplayStatics_WorldHasTag");
static_assert(sizeof(PhxGameplayStatics_WorldHasTag) == 0x000018, "Wrong size on PhxGameplayStatics_WorldHasTag");
static_assert(offsetof(PhxGameplayStatics_WorldHasTag, WorldContextObject) == 0x000000, "Member 'PhxGameplayStatics_WorldHasTag::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_WorldHasTag, TagToCheck) == 0x000008, "Member 'PhxGameplayStatics_WorldHasTag::TagToCheck' has a wrong offset!");
static_assert(offsetof(PhxGameplayStatics_WorldHasTag, ReturnValue) == 0x000010, "Member 'PhxGameplayStatics_WorldHasTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_SpawnAI.SpawnAI
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_SpawnAI_SpawnAI final
{
public:
	class APhxAISpawner_Character*                Spawner;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpawnDelay;                                        // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAIBlueprintAction_SpawnAI*          ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_SpawnAI_SpawnAI) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_SpawnAI_SpawnAI");
static_assert(sizeof(PhxAIBlueprintAction_SpawnAI_SpawnAI) == 0x000018, "Wrong size on PhxAIBlueprintAction_SpawnAI_SpawnAI");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAI, Spawner) == 0x000000, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAI::Spawner' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAI, SpawnDelay) == 0x000008, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAI::SpawnDelay' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAI, ReturnValue) == 0x000010, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_SpawnAI.SpawnAIFromComponent
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent final
{
public:
	class UPhxAISpawnerComponent_Character*       SpawnerComponent;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpawnDelay;                                        // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAIBlueprintAction_SpawnAI*          ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent");
static_assert(sizeof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent) == 0x000018, "Wrong size on PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent, SpawnerComponent) == 0x000000, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent::SpawnerComponent' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent, SpawnDelay) == 0x000008, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent::SpawnDelay' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent, ReturnValue) == 0x000010, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_SpawnAI.SpawnAIFromEncounterNetwork
// 0x0040 (0x0040 - 0x0000)
struct PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork final
{
public:
	class APhxAIEncounterNetwork*                 EncounterNetwork;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UPhxAICharacterDefinition> AICharacterDefinition;                           // 0x0008(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpawnDelay;                                        // 0x0030(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAIBlueprintAction_SpawnAI*          ReturnValue;                                       // 0x0038(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork");
static_assert(sizeof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork) == 0x000040, "Wrong size on PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork, EncounterNetwork) == 0x000000, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork::EncounterNetwork' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork, AICharacterDefinition) == 0x000008, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork::AICharacterDefinition' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork, SpawnDelay) == 0x000030, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork::SpawnDelay' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork, ReturnValue) == 0x000038, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_SpawnAI.SpawnCompanion
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_SpawnAI_SpawnCompanion final
{
public:
	class APhxAISpawner_Companion*                Spawner;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_SpawnAI*          ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_SpawnAI_SpawnCompanion) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_SpawnAI_SpawnCompanion");
static_assert(sizeof(PhxAIBlueprintAction_SpawnAI_SpawnCompanion) == 0x000010, "Wrong size on PhxAIBlueprintAction_SpawnAI_SpawnCompanion");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnCompanion, Spawner) == 0x000000, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnCompanion::Spawner' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_SpawnCompanion, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintAction_SpawnAI_SpawnCompanion::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_SpawnAI.HandleAISpawned
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_SpawnAI_HandleAISpawned final
{
public:
	class APhxAICharacter*                        SpawnedAI;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAISpawnResultCode                         ResultCode;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SpawnUid;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_SpawnAI_HandleAISpawned) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_SpawnAI_HandleAISpawned");
static_assert(sizeof(PhxAIBlueprintAction_SpawnAI_HandleAISpawned) == 0x000010, "Wrong size on PhxAIBlueprintAction_SpawnAI_HandleAISpawned");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_HandleAISpawned, SpawnedAI) == 0x000000, "Member 'PhxAIBlueprintAction_SpawnAI_HandleAISpawned::SpawnedAI' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_HandleAISpawned, ResultCode) == 0x000008, "Member 'PhxAIBlueprintAction_SpawnAI_HandleAISpawned::ResultCode' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_SpawnAI_HandleAISpawned, SpawnUid) == 0x00000C, "Member 'PhxAIBlueprintAction_SpawnAI_HandleAISpawned::SpawnUid' has a wrong offset!");

// Function Phoenix.AchievementUpdatePayload.OnGetAchievements
// 0x0018 (0x0018 - 0x0000)
struct AchievementUpdatePayload_OnGetAchievements final
{
public:
	bool                                          bResult;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class USDSAchievement*>                Achievements;                                      // 0x0008(0x0010)(ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(AchievementUpdatePayload_OnGetAchievements) == 0x000008, "Wrong alignment on AchievementUpdatePayload_OnGetAchievements");
static_assert(sizeof(AchievementUpdatePayload_OnGetAchievements) == 0x000018, "Wrong size on AchievementUpdatePayload_OnGetAchievements");
static_assert(offsetof(AchievementUpdatePayload_OnGetAchievements, bResult) == 0x000000, "Member 'AchievementUpdatePayload_OnGetAchievements::bResult' has a wrong offset!");
static_assert(offsetof(AchievementUpdatePayload_OnGetAchievements, Achievements) == 0x000008, "Member 'AchievementUpdatePayload_OnGetAchievements::Achievements' has a wrong offset!");

// Function Phoenix.PhxMaterialCostMeterManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxMaterialCostMeterManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxMaterialCostMeterManager*           ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMaterialCostMeterManager_Get) == 0x000008, "Wrong alignment on PhxMaterialCostMeterManager_Get");
static_assert(sizeof(PhxMaterialCostMeterManager_Get) == 0x000010, "Wrong size on PhxMaterialCostMeterManager_Get");
static_assert(offsetof(PhxMaterialCostMeterManager_Get, WorldContextObject) == 0x000000, "Member 'PhxMaterialCostMeterManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxMaterialCostMeterManager_Get, ReturnValue) == 0x000008, "Member 'PhxMaterialCostMeterManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMaterialCostMeterManager.SetMaterialCostMeterVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxMaterialCostMeterManager_SetMaterialCostMeterVisibility final
{
public:
	ESlateVisibility                              Visibility;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMaterialCostMeterManager_SetMaterialCostMeterVisibility) == 0x000001, "Wrong alignment on PhxMaterialCostMeterManager_SetMaterialCostMeterVisibility");
static_assert(sizeof(PhxMaterialCostMeterManager_SetMaterialCostMeterVisibility) == 0x000001, "Wrong size on PhxMaterialCostMeterManager_SetMaterialCostMeterVisibility");
static_assert(offsetof(PhxMaterialCostMeterManager_SetMaterialCostMeterVisibility, Visibility) == 0x000000, "Member 'PhxMaterialCostMeterManager_SetMaterialCostMeterVisibility::Visibility' has a wrong offset!");

// Function Phoenix.PhxMaterialCostMeterManager.IsMaterialCostMeterVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxMaterialCostMeterManager_IsMaterialCostMeterVisible final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMaterialCostMeterManager_IsMaterialCostMeterVisible) == 0x000001, "Wrong alignment on PhxMaterialCostMeterManager_IsMaterialCostMeterVisible");
static_assert(sizeof(PhxMaterialCostMeterManager_IsMaterialCostMeterVisible) == 0x000001, "Wrong size on PhxMaterialCostMeterManager_IsMaterialCostMeterVisible");
static_assert(offsetof(PhxMaterialCostMeterManager_IsMaterialCostMeterVisible, ReturnValue) == 0x000000, "Member 'PhxMaterialCostMeterManager_IsMaterialCostMeterVisible::ReturnValue' has a wrong offset!");

// Function Phoenix.LogoScreenState.MediaOpenFailed
// 0x0010 (0x0010 - 0x0000)
struct LogoScreenState_MediaOpenFailed final
{
public:
	class FString                                 FailedUrl;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(LogoScreenState_MediaOpenFailed) == 0x000008, "Wrong alignment on LogoScreenState_MediaOpenFailed");
static_assert(sizeof(LogoScreenState_MediaOpenFailed) == 0x000010, "Wrong size on LogoScreenState_MediaOpenFailed");
static_assert(offsetof(LogoScreenState_MediaOpenFailed, FailedUrl) == 0x000000, "Member 'LogoScreenState_MediaOpenFailed::FailedUrl' has a wrong offset!");

// Function Phoenix.MenuButton.SetImageLabel
// 0x0008 (0x0008 - 0x0000)
struct MenuButton_SetImageLabel final
{
public:
	class UTexture*                               Texture;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MenuButton_SetImageLabel) == 0x000008, "Wrong alignment on MenuButton_SetImageLabel");
static_assert(sizeof(MenuButton_SetImageLabel) == 0x000008, "Wrong size on MenuButton_SetImageLabel");
static_assert(offsetof(MenuButton_SetImageLabel, Texture) == 0x000000, "Member 'MenuButton_SetImageLabel::Texture' has a wrong offset!");

// Function Phoenix.MenuButton.SetTextColor
// 0x0010 (0x0010 - 0x0000)
struct MenuButton_SetTextColor final
{
public:
	struct FLinearColor                           LinearColor;                                       // 0x0000(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MenuButton_SetTextColor) == 0x000004, "Wrong alignment on MenuButton_SetTextColor");
static_assert(sizeof(MenuButton_SetTextColor) == 0x000010, "Wrong size on MenuButton_SetTextColor");
static_assert(offsetof(MenuButton_SetTextColor, LinearColor) == 0x000000, "Member 'MenuButton_SetTextColor::LinearColor' has a wrong offset!");

// Function Phoenix.MenuButton.SetTextLabel
// 0x0010 (0x0010 - 0x0000)
struct MenuButton_SetTextLabel final
{
public:
	class FString                                 TextLabel;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MenuButton_SetTextLabel) == 0x000008, "Wrong alignment on MenuButton_SetTextLabel");
static_assert(sizeof(MenuButton_SetTextLabel) == 0x000010, "Wrong size on MenuButton_SetTextLabel");
static_assert(offsetof(MenuButton_SetTextLabel, TextLabel) == 0x000000, "Member 'MenuButton_SetTextLabel::TextLabel' has a wrong offset!");

// Function Phoenix.MicroSwitchboardPuzzleFSM.InteractExecuted
// 0x0008 (0x0008 - 0x0000)
struct MicroSwitchboardPuzzleFSM_InteractExecuted final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MicroSwitchboardPuzzleFSM_InteractExecuted) == 0x000008, "Wrong alignment on MicroSwitchboardPuzzleFSM_InteractExecuted");
static_assert(sizeof(MicroSwitchboardPuzzleFSM_InteractExecuted) == 0x000008, "Wrong size on MicroSwitchboardPuzzleFSM_InteractExecuted");
static_assert(offsetof(MicroSwitchboardPuzzleFSM_InteractExecuted, InteractedBy) == 0x000000, "Member 'MicroSwitchboardPuzzleFSM_InteractExecuted::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxScriptedEventCharacterBaseState.HandleGamePaused
// 0x0001 (0x0001 - 0x0000)
struct PhxScriptedEventCharacterBaseState_HandleGamePaused final
{
public:
	bool                                          bPaused;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventCharacterBaseState_HandleGamePaused) == 0x000001, "Wrong alignment on PhxScriptedEventCharacterBaseState_HandleGamePaused");
static_assert(sizeof(PhxScriptedEventCharacterBaseState_HandleGamePaused) == 0x000001, "Wrong size on PhxScriptedEventCharacterBaseState_HandleGamePaused");
static_assert(offsetof(PhxScriptedEventCharacterBaseState_HandleGamePaused, bPaused) == 0x000000, "Member 'PhxScriptedEventCharacterBaseState_HandleGamePaused::bPaused' has a wrong offset!");

// Function Phoenix.PhxAIAbilityTask_AttackBase.HandleAttackStateBegin
// 0x0010 (0x0010 - 0x0000)
struct PhxAIAbilityTask_AttackBase_HandleAttackStateBegin final
{
public:
	class APhxCharacter*                          InCharacter;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAttackState*                           InAttackState;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIAbilityTask_AttackBase_HandleAttackStateBegin) == 0x000008, "Wrong alignment on PhxAIAbilityTask_AttackBase_HandleAttackStateBegin");
static_assert(sizeof(PhxAIAbilityTask_AttackBase_HandleAttackStateBegin) == 0x000010, "Wrong size on PhxAIAbilityTask_AttackBase_HandleAttackStateBegin");
static_assert(offsetof(PhxAIAbilityTask_AttackBase_HandleAttackStateBegin, InCharacter) == 0x000000, "Member 'PhxAIAbilityTask_AttackBase_HandleAttackStateBegin::InCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIAbilityTask_AttackBase_HandleAttackStateBegin, InAttackState) == 0x000008, "Member 'PhxAIAbilityTask_AttackBase_HandleAttackStateBegin::InAttackState' has a wrong offset!");

// Function Phoenix.PhxAIAbilityTask_AttackBase.HandleAttackStateFinished
// 0x0010 (0x0010 - 0x0000)
struct PhxAIAbilityTask_AttackBase_HandleAttackStateFinished final
{
public:
	class APhxCharacter*                          InCharacter;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAttackState*                           InAttackState;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIAbilityTask_AttackBase_HandleAttackStateFinished) == 0x000008, "Wrong alignment on PhxAIAbilityTask_AttackBase_HandleAttackStateFinished");
static_assert(sizeof(PhxAIAbilityTask_AttackBase_HandleAttackStateFinished) == 0x000010, "Wrong size on PhxAIAbilityTask_AttackBase_HandleAttackStateFinished");
static_assert(offsetof(PhxAIAbilityTask_AttackBase_HandleAttackStateFinished, InCharacter) == 0x000000, "Member 'PhxAIAbilityTask_AttackBase_HandleAttackStateFinished::InCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIAbilityTask_AttackBase_HandleAttackStateFinished, InAttackState) == 0x000008, "Member 'PhxAIAbilityTask_AttackBase_HandleAttackStateFinished::InAttackState' has a wrong offset!");

// Function Phoenix.PhxAIAbilityTask_RunAttackAbility.OnAbilityFinished
// 0x000C (0x000C - 0x0000)
struct PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished final
{
public:
	struct FGameplayTag                           InTag;                                             // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NewCount;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished) == 0x000004, "Wrong alignment on PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished");
static_assert(sizeof(PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished) == 0x00000C, "Wrong size on PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished");
static_assert(offsetof(PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished, InTag) == 0x000000, "Member 'PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished::InTag' has a wrong offset!");
static_assert(offsetof(PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished, NewCount) == 0x000008, "Member 'PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished::NewCount' has a wrong offset!");

// Function Phoenix.PhxCharacterInteractionComponent.CanAutoExecute
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInteractionComponent_CanAutoExecute final
{
public:
	const class UInteractableComponent*           focus;                                             // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInteractionComponent_CanAutoExecute) == 0x000008, "Wrong alignment on PhxCharacterInteractionComponent_CanAutoExecute");
static_assert(sizeof(PhxCharacterInteractionComponent_CanAutoExecute) == 0x000010, "Wrong size on PhxCharacterInteractionComponent_CanAutoExecute");
static_assert(offsetof(PhxCharacterInteractionComponent_CanAutoExecute, focus) == 0x000000, "Member 'PhxCharacterInteractionComponent_CanAutoExecute::focus' has a wrong offset!");
static_assert(offsetof(PhxCharacterInteractionComponent_CanAutoExecute, ReturnValue) == 0x000008, "Member 'PhxCharacterInteractionComponent_CanAutoExecute::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInteractionComponent.GetMostRecentInteraction
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInteractionComponent_GetMostRecentInteraction final
{
public:
	class UInteraction*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInteractionComponent_GetMostRecentInteraction) == 0x000008, "Wrong alignment on PhxCharacterInteractionComponent_GetMostRecentInteraction");
static_assert(sizeof(PhxCharacterInteractionComponent_GetMostRecentInteraction) == 0x000008, "Wrong size on PhxCharacterInteractionComponent_GetMostRecentInteraction");
static_assert(offsetof(PhxCharacterInteractionComponent_GetMostRecentInteraction, ReturnValue) == 0x000000, "Member 'PhxCharacterInteractionComponent_GetMostRecentInteraction::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerInteractionComponent.HandleGamePaused
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerInteractionComponent_HandleGamePaused final
{
public:
	bool                                          InPaused;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerInteractionComponent_HandleGamePaused) == 0x000001, "Wrong alignment on PhxPlayerInteractionComponent_HandleGamePaused");
static_assert(sizeof(PhxPlayerInteractionComponent_HandleGamePaused) == 0x000001, "Wrong size on PhxPlayerInteractionComponent_HandleGamePaused");
static_assert(offsetof(PhxPlayerInteractionComponent_HandleGamePaused, InPaused) == 0x000000, "Member 'PhxPlayerInteractionComponent_HandleGamePaused::InPaused' has a wrong offset!");

// Function Phoenix.PhxPlayerController.AddKeyMappingForInput
// 0x0030 (0x0030 - 0x0000)
struct PhxPlayerController_AddKeyMappingForInput final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AxisScale;                                         // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FKey                                   NewKey;                                            // 0x0010(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0028(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerController_AddKeyMappingForInput) == 0x000008, "Wrong alignment on PhxPlayerController_AddKeyMappingForInput");
static_assert(sizeof(PhxPlayerController_AddKeyMappingForInput) == 0x000030, "Wrong size on PhxPlayerController_AddKeyMappingForInput");
static_assert(offsetof(PhxPlayerController_AddKeyMappingForInput, ActionName) == 0x000000, "Member 'PhxPlayerController_AddKeyMappingForInput::ActionName' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_AddKeyMappingForInput, AxisScale) == 0x000008, "Member 'PhxPlayerController_AddKeyMappingForInput::AxisScale' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_AddKeyMappingForInput, NewKey) == 0x000010, "Member 'PhxPlayerController_AddKeyMappingForInput::NewKey' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_AddKeyMappingForInput, ReturnValue) == 0x000028, "Member 'PhxPlayerController_AddKeyMappingForInput::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.AdjustCuedRespawn
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerController_AdjustCuedRespawn final
{
public:
	float                                         RespawnTime;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_AdjustCuedRespawn) == 0x000004, "Wrong alignment on PhxPlayerController_AdjustCuedRespawn");
static_assert(sizeof(PhxPlayerController_AdjustCuedRespawn) == 0x000004, "Wrong size on PhxPlayerController_AdjustCuedRespawn");
static_assert(offsetof(PhxPlayerController_AdjustCuedRespawn, RespawnTime) == 0x000000, "Member 'PhxPlayerController_AdjustCuedRespawn::RespawnTime' has a wrong offset!");

// Function Phoenix.PhxPlayerController.ApplyInputMappingSettings
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_ApplyInputMappingSettings final
{
public:
	class UPhxInputMappingSettings*               NewInputMappingAsset;                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_ApplyInputMappingSettings) == 0x000008, "Wrong alignment on PhxPlayerController_ApplyInputMappingSettings");
static_assert(sizeof(PhxPlayerController_ApplyInputMappingSettings) == 0x000008, "Wrong size on PhxPlayerController_ApplyInputMappingSettings");
static_assert(offsetof(PhxPlayerController_ApplyInputMappingSettings, NewInputMappingAsset) == 0x000000, "Member 'PhxPlayerController_ApplyInputMappingSettings::NewInputMappingAsset' has a wrong offset!");

// Function Phoenix.PhxPlayerController.ApplySavedInputSettings
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_ApplySavedInputSettings final
{
public:
	class UPhxInputMappingSettings*               InputMappingAsset;                                 // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_ApplySavedInputSettings) == 0x000008, "Wrong alignment on PhxPlayerController_ApplySavedInputSettings");
static_assert(sizeof(PhxPlayerController_ApplySavedInputSettings) == 0x000008, "Wrong size on PhxPlayerController_ApplySavedInputSettings");
static_assert(offsetof(PhxPlayerController_ApplySavedInputSettings, InputMappingAsset) == 0x000000, "Member 'PhxPlayerController_ApplySavedInputSettings::InputMappingAsset' has a wrong offset!");

// Function Phoenix.PhxPlayerController.CopyKeyboardActionInputMapping
// 0x0018 (0x0018 - 0x0000)
struct PhxPlayerController_CopyKeyboardActionInputMapping final
{
public:
	class UPhxInputMappingSettings*               InputSettings;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FPhxInputActionMappingSetting>  ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_CopyKeyboardActionInputMapping) == 0x000008, "Wrong alignment on PhxPlayerController_CopyKeyboardActionInputMapping");
static_assert(sizeof(PhxPlayerController_CopyKeyboardActionInputMapping) == 0x000018, "Wrong size on PhxPlayerController_CopyKeyboardActionInputMapping");
static_assert(offsetof(PhxPlayerController_CopyKeyboardActionInputMapping, InputSettings) == 0x000000, "Member 'PhxPlayerController_CopyKeyboardActionInputMapping::InputSettings' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_CopyKeyboardActionInputMapping, ReturnValue) == 0x000008, "Member 'PhxPlayerController_CopyKeyboardActionInputMapping::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.CopyKeyboardAxisInputMapping
// 0x0018 (0x0018 - 0x0000)
struct PhxPlayerController_CopyKeyboardAxisInputMapping final
{
public:
	class UPhxInputMappingSettings*               InputSettings;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FPhxInputAxisMappingSetting>    ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_CopyKeyboardAxisInputMapping) == 0x000008, "Wrong alignment on PhxPlayerController_CopyKeyboardAxisInputMapping");
static_assert(sizeof(PhxPlayerController_CopyKeyboardAxisInputMapping) == 0x000018, "Wrong size on PhxPlayerController_CopyKeyboardAxisInputMapping");
static_assert(offsetof(PhxPlayerController_CopyKeyboardAxisInputMapping, InputSettings) == 0x000000, "Member 'PhxPlayerController_CopyKeyboardAxisInputMapping::InputSettings' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_CopyKeyboardAxisInputMapping, ReturnValue) == 0x000008, "Member 'PhxPlayerController_CopyKeyboardAxisInputMapping::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.CueRespawn
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_CueRespawn final
{
public:
	bool                                          bFast;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         OverrideRespawnInterval;                           // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_CueRespawn) == 0x000004, "Wrong alignment on PhxPlayerController_CueRespawn");
static_assert(sizeof(PhxPlayerController_CueRespawn) == 0x000008, "Wrong size on PhxPlayerController_CueRespawn");
static_assert(offsetof(PhxPlayerController_CueRespawn, bFast) == 0x000000, "Member 'PhxPlayerController_CueRespawn::bFast' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_CueRespawn, OverrideRespawnInterval) == 0x000004, "Member 'PhxPlayerController_CueRespawn::OverrideRespawnInterval' has a wrong offset!");

// Function Phoenix.PhxPlayerController.GetCheatManager
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_GetCheatManager final
{
public:
	class UPhxCheatManager*                       ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_GetCheatManager) == 0x000008, "Wrong alignment on PhxPlayerController_GetCheatManager");
static_assert(sizeof(PhxPlayerController_GetCheatManager) == 0x000008, "Wrong size on PhxPlayerController_GetCheatManager");
static_assert(offsetof(PhxPlayerController_GetCheatManager, ReturnValue) == 0x000000, "Member 'PhxPlayerController_GetCheatManager::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.GetPlayerCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_GetPlayerCharacter final
{
public:
	class APhxPlayerCharacter*                    ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_GetPlayerCharacter) == 0x000008, "Wrong alignment on PhxPlayerController_GetPlayerCharacter");
static_assert(sizeof(PhxPlayerController_GetPlayerCharacter) == 0x000008, "Wrong size on PhxPlayerController_GetPlayerCharacter");
static_assert(offsetof(PhxPlayerController_GetPlayerCharacter, ReturnValue) == 0x000000, "Member 'PhxPlayerController_GetPlayerCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.LockOutActions
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_LockOutActions final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_LockOutActions) == 0x000001, "Wrong alignment on PhxPlayerController_LockOutActions");
static_assert(sizeof(PhxPlayerController_LockOutActions) == 0x000001, "Wrong size on PhxPlayerController_LockOutActions");
static_assert(offsetof(PhxPlayerController_LockOutActions, ReturnValue) == 0x000000, "Member 'PhxPlayerController_LockOutActions::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.LockOutCorpseStomp
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_LockOutCorpseStomp final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_LockOutCorpseStomp) == 0x000001, "Wrong alignment on PhxPlayerController_LockOutCorpseStomp");
static_assert(sizeof(PhxPlayerController_LockOutCorpseStomp) == 0x000001, "Wrong size on PhxPlayerController_LockOutCorpseStomp");
static_assert(offsetof(PhxPlayerController_LockOutCorpseStomp, ReturnValue) == 0x000000, "Member 'PhxPlayerController_LockOutCorpseStomp::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.LockOutEquipment
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_LockOutEquipment final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_LockOutEquipment) == 0x000001, "Wrong alignment on PhxPlayerController_LockOutEquipment");
static_assert(sizeof(PhxPlayerController_LockOutEquipment) == 0x000001, "Wrong size on PhxPlayerController_LockOutEquipment");
static_assert(offsetof(PhxPlayerController_LockOutEquipment, ReturnValue) == 0x000000, "Member 'PhxPlayerController_LockOutEquipment::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.LockOutInteractions
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_LockOutInteractions final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_LockOutInteractions) == 0x000001, "Wrong alignment on PhxPlayerController_LockOutInteractions");
static_assert(sizeof(PhxPlayerController_LockOutInteractions) == 0x000001, "Wrong size on PhxPlayerController_LockOutInteractions");
static_assert(offsetof(PhxPlayerController_LockOutInteractions, ReturnValue) == 0x000000, "Member 'PhxPlayerController_LockOutInteractions::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.LockOutMenu
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_LockOutMenu final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_LockOutMenu) == 0x000001, "Wrong alignment on PhxPlayerController_LockOutMenu");
static_assert(sizeof(PhxPlayerController_LockOutMenu) == 0x000001, "Wrong size on PhxPlayerController_LockOutMenu");
static_assert(offsetof(PhxPlayerController_LockOutMenu, ReturnValue) == 0x000000, "Member 'PhxPlayerController_LockOutMenu::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.LockOutMovement
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_LockOutMovement final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_LockOutMovement) == 0x000001, "Wrong alignment on PhxPlayerController_LockOutMovement");
static_assert(sizeof(PhxPlayerController_LockOutMovement) == 0x000001, "Wrong size on PhxPlayerController_LockOutMovement");
static_assert(offsetof(PhxPlayerController_LockOutMovement, ReturnValue) == 0x000000, "Member 'PhxPlayerController_LockOutMovement::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.OnDialogueStarted
// 0x0098 (0x0098 - 0x0000)
struct PhxPlayerController_OnDialogueStarted final
{
public:
	class AActor*                                 SpeakingActor;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FDialogueNode                          Dialogue;                                          // 0x0008(0x0090)(Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_OnDialogueStarted) == 0x000008, "Wrong alignment on PhxPlayerController_OnDialogueStarted");
static_assert(sizeof(PhxPlayerController_OnDialogueStarted) == 0x000098, "Wrong size on PhxPlayerController_OnDialogueStarted");
static_assert(offsetof(PhxPlayerController_OnDialogueStarted, SpeakingActor) == 0x000000, "Member 'PhxPlayerController_OnDialogueStarted::SpeakingActor' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_OnDialogueStarted, Dialogue) == 0x000008, "Member 'PhxPlayerController_OnDialogueStarted::Dialogue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.OnInteractionExecuted
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_OnInteractionExecuted final
{
public:
	const class UInteraction*                     Interaction;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_OnInteractionExecuted) == 0x000008, "Wrong alignment on PhxPlayerController_OnInteractionExecuted");
static_assert(sizeof(PhxPlayerController_OnInteractionExecuted) == 0x000008, "Wrong size on PhxPlayerController_OnInteractionExecuted");
static_assert(offsetof(PhxPlayerController_OnInteractionExecuted, Interaction) == 0x000000, "Member 'PhxPlayerController_OnInteractionExecuted::Interaction' has a wrong offset!");

// Function Phoenix.PhxPlayerController.RemoveKeyMappingForInput
// 0x0030 (0x0030 - 0x0000)
struct PhxPlayerController_RemoveKeyMappingForInput final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AxisScale;                                         // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FKey                                   CurrentKey;                                        // 0x0010(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0028(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerController_RemoveKeyMappingForInput) == 0x000008, "Wrong alignment on PhxPlayerController_RemoveKeyMappingForInput");
static_assert(sizeof(PhxPlayerController_RemoveKeyMappingForInput) == 0x000030, "Wrong size on PhxPlayerController_RemoveKeyMappingForInput");
static_assert(offsetof(PhxPlayerController_RemoveKeyMappingForInput, ActionName) == 0x000000, "Member 'PhxPlayerController_RemoveKeyMappingForInput::ActionName' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_RemoveKeyMappingForInput, AxisScale) == 0x000008, "Member 'PhxPlayerController_RemoveKeyMappingForInput::AxisScale' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_RemoveKeyMappingForInput, CurrentKey) == 0x000010, "Member 'PhxPlayerController_RemoveKeyMappingForInput::CurrentKey' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_RemoveKeyMappingForInput, ReturnValue) == 0x000028, "Member 'PhxPlayerController_RemoveKeyMappingForInput::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.RequestCombatTutorial
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_RequestCombatTutorial final
{
public:
	struct FGameplayTag                           TutorialTag;                                       // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_RequestCombatTutorial) == 0x000004, "Wrong alignment on PhxPlayerController_RequestCombatTutorial");
static_assert(sizeof(PhxPlayerController_RequestCombatTutorial) == 0x000008, "Wrong size on PhxPlayerController_RequestCombatTutorial");
static_assert(offsetof(PhxPlayerController_RequestCombatTutorial, TutorialTag) == 0x000000, "Member 'PhxPlayerController_RequestCombatTutorial::TutorialTag' has a wrong offset!");

// Function Phoenix.PhxPlayerController.SaveDefaultKeyboardMappings
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_SaveDefaultKeyboardMappings final
{
public:
	class UPhxInputMappingSettings*               InputSettings;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_SaveDefaultKeyboardMappings) == 0x000008, "Wrong alignment on PhxPlayerController_SaveDefaultKeyboardMappings");
static_assert(sizeof(PhxPlayerController_SaveDefaultKeyboardMappings) == 0x000008, "Wrong size on PhxPlayerController_SaveDefaultKeyboardMappings");
static_assert(offsetof(PhxPlayerController_SaveDefaultKeyboardMappings, InputSettings) == 0x000000, "Member 'PhxPlayerController_SaveDefaultKeyboardMappings::InputSettings' has a wrong offset!");

// Function Phoenix.PhxPlayerController.SetAllowPhotoMode
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_SetAllowPhotoMode final
{
public:
	bool                                          bInAllowPhotoMode;                                 // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_SetAllowPhotoMode) == 0x000001, "Wrong alignment on PhxPlayerController_SetAllowPhotoMode");
static_assert(sizeof(PhxPlayerController_SetAllowPhotoMode) == 0x000001, "Wrong size on PhxPlayerController_SetAllowPhotoMode");
static_assert(offsetof(PhxPlayerController_SetAllowPhotoMode, bInAllowPhotoMode) == 0x000000, "Member 'PhxPlayerController_SetAllowPhotoMode::bInAllowPhotoMode' has a wrong offset!");

// Function Phoenix.PhxPlayerController.SetFullScreenMediaPlaying
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_SetFullScreenMediaPlaying final
{
public:
	bool                                          OnOff;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_SetFullScreenMediaPlaying) == 0x000001, "Wrong alignment on PhxPlayerController_SetFullScreenMediaPlaying");
static_assert(sizeof(PhxPlayerController_SetFullScreenMediaPlaying) == 0x000001, "Wrong size on PhxPlayerController_SetFullScreenMediaPlaying");
static_assert(offsetof(PhxPlayerController_SetFullScreenMediaPlaying, OnOff) == 0x000000, "Member 'PhxPlayerController_SetFullScreenMediaPlaying::OnOff' has a wrong offset!");

// Function Phoenix.PhxPlayerController.SetPhotoModeActive
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_SetPhotoModeActive final
{
public:
	bool                                          bActive;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_SetPhotoModeActive) == 0x000001, "Wrong alignment on PhxPlayerController_SetPhotoModeActive");
static_assert(sizeof(PhxPlayerController_SetPhotoModeActive) == 0x000001, "Wrong size on PhxPlayerController_SetPhotoModeActive");
static_assert(offsetof(PhxPlayerController_SetPhotoModeActive, bActive) == 0x000000, "Member 'PhxPlayerController_SetPhotoModeActive::bActive' has a wrong offset!");

// Function Phoenix.PhxPlayerController.SetPlayerAim
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_SetPlayerAim final
{
public:
	float                                         Pitch;                                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Yaw;                                               // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_SetPlayerAim) == 0x000004, "Wrong alignment on PhxPlayerController_SetPlayerAim");
static_assert(sizeof(PhxPlayerController_SetPlayerAim) == 0x000008, "Wrong size on PhxPlayerController_SetPlayerAim");
static_assert(offsetof(PhxPlayerController_SetPlayerAim, Pitch) == 0x000000, "Member 'PhxPlayerController_SetPlayerAim::Pitch' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_SetPlayerAim, Yaw) == 0x000004, "Member 'PhxPlayerController_SetPlayerAim::Yaw' has a wrong offset!");

// Function Phoenix.PhxPlayerController.UpdateKeyMappingForInput
// 0x0048 (0x0048 - 0x0000)
struct PhxPlayerController_UpdateKeyMappingForInput final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AxisScale;                                         // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FKey                                   CurrentKey;                                        // 0x0010(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FKey                                   NewKey;                                            // 0x0028(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0040(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_41[0x7];                                       // 0x0041(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerController_UpdateKeyMappingForInput) == 0x000008, "Wrong alignment on PhxPlayerController_UpdateKeyMappingForInput");
static_assert(sizeof(PhxPlayerController_UpdateKeyMappingForInput) == 0x000048, "Wrong size on PhxPlayerController_UpdateKeyMappingForInput");
static_assert(offsetof(PhxPlayerController_UpdateKeyMappingForInput, ActionName) == 0x000000, "Member 'PhxPlayerController_UpdateKeyMappingForInput::ActionName' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_UpdateKeyMappingForInput, AxisScale) == 0x000008, "Member 'PhxPlayerController_UpdateKeyMappingForInput::AxisScale' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_UpdateKeyMappingForInput, CurrentKey) == 0x000010, "Member 'PhxPlayerController_UpdateKeyMappingForInput::CurrentKey' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_UpdateKeyMappingForInput, NewKey) == 0x000028, "Member 'PhxPlayerController_UpdateKeyMappingForInput::NewKey' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_UpdateKeyMappingForInput, ReturnValue) == 0x000040, "Member 'PhxPlayerController_UpdateKeyMappingForInput::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.GetCameraRig
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_GetCameraRig final
{
public:
	class APhxCameraRig*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_GetCameraRig) == 0x000008, "Wrong alignment on PhxPlayerController_GetCameraRig");
static_assert(sizeof(PhxPlayerController_GetCameraRig) == 0x000008, "Wrong size on PhxPlayerController_GetCameraRig");
static_assert(offsetof(PhxPlayerController_GetCameraRig, ReturnValue) == 0x000000, "Member 'PhxPlayerController_GetCameraRig::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.GetInputMappingSettings
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_GetInputMappingSettings final
{
public:
	class UPhxInputMappingSettings*               ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_GetInputMappingSettings) == 0x000008, "Wrong alignment on PhxPlayerController_GetInputMappingSettings");
static_assert(sizeof(PhxPlayerController_GetInputMappingSettings) == 0x000008, "Wrong size on PhxPlayerController_GetInputMappingSettings");
static_assert(offsetof(PhxPlayerController_GetInputMappingSettings, ReturnValue) == 0x000000, "Member 'PhxPlayerController_GetInputMappingSettings::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.GetUIComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_GetUIComponent final
{
public:
	class UPhxPlayerControllerUIComponent*        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_GetUIComponent) == 0x000008, "Wrong alignment on PhxPlayerController_GetUIComponent");
static_assert(sizeof(PhxPlayerController_GetUIComponent) == 0x000008, "Wrong size on PhxPlayerController_GetUIComponent");
static_assert(offsetof(PhxPlayerController_GetUIComponent, ReturnValue) == 0x000000, "Member 'PhxPlayerController_GetUIComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.IsControllerInState
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerController_IsControllerInState final
{
public:
	TSubclassOf<class UState>                     StateClass;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerController_IsControllerInState) == 0x000008, "Wrong alignment on PhxPlayerController_IsControllerInState");
static_assert(sizeof(PhxPlayerController_IsControllerInState) == 0x000010, "Wrong size on PhxPlayerController_IsControllerInState");
static_assert(offsetof(PhxPlayerController_IsControllerInState, StateClass) == 0x000000, "Member 'PhxPlayerController_IsControllerInState::StateClass' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_IsControllerInState, ReturnValue) == 0x000008, "Member 'PhxPlayerController_IsControllerInState::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.IsFullScreenMediaPlaying
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_IsFullScreenMediaPlaying final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_IsFullScreenMediaPlaying) == 0x000001, "Wrong alignment on PhxPlayerController_IsFullScreenMediaPlaying");
static_assert(sizeof(PhxPlayerController_IsFullScreenMediaPlaying) == 0x000001, "Wrong size on PhxPlayerController_IsFullScreenMediaPlaying");
static_assert(offsetof(PhxPlayerController_IsFullScreenMediaPlaying, ReturnValue) == 0x000000, "Member 'PhxPlayerController_IsFullScreenMediaPlaying::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.IsGamePadInUse
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_IsGamePadInUse final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_IsGamePadInUse) == 0x000001, "Wrong alignment on PhxPlayerController_IsGamePadInUse");
static_assert(sizeof(PhxPlayerController_IsGamePadInUse) == 0x000001, "Wrong size on PhxPlayerController_IsGamePadInUse");
static_assert(offsetof(PhxPlayerController_IsGamePadInUse, ReturnValue) == 0x000000, "Member 'PhxPlayerController_IsGamePadInUse::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.IsGamePadLastOrRecentlyUsed
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerController_IsGamePadLastOrRecentlyUsed final
{
public:
	float                                         TimeThreshold;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0004(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerController_IsGamePadLastOrRecentlyUsed) == 0x000004, "Wrong alignment on PhxPlayerController_IsGamePadLastOrRecentlyUsed");
static_assert(sizeof(PhxPlayerController_IsGamePadLastOrRecentlyUsed) == 0x000008, "Wrong size on PhxPlayerController_IsGamePadLastOrRecentlyUsed");
static_assert(offsetof(PhxPlayerController_IsGamePadLastOrRecentlyUsed, TimeThreshold) == 0x000000, "Member 'PhxPlayerController_IsGamePadLastOrRecentlyUsed::TimeThreshold' has a wrong offset!");
static_assert(offsetof(PhxPlayerController_IsGamePadLastOrRecentlyUsed, ReturnValue) == 0x000004, "Member 'PhxPlayerController_IsGamePadLastOrRecentlyUsed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.IsPhotoModeActive
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_IsPhotoModeActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_IsPhotoModeActive) == 0x000001, "Wrong alignment on PhxPlayerController_IsPhotoModeActive");
static_assert(sizeof(PhxPlayerController_IsPhotoModeActive) == 0x000001, "Wrong size on PhxPlayerController_IsPhotoModeActive");
static_assert(offsetof(PhxPlayerController_IsPhotoModeActive, ReturnValue) == 0x000000, "Member 'PhxPlayerController_IsPhotoModeActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.IsPhotoModeAllowed
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_IsPhotoModeAllowed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_IsPhotoModeAllowed) == 0x000001, "Wrong alignment on PhxPlayerController_IsPhotoModeAllowed");
static_assert(sizeof(PhxPlayerController_IsPhotoModeAllowed) == 0x000001, "Wrong size on PhxPlayerController_IsPhotoModeAllowed");
static_assert(offsetof(PhxPlayerController_IsPhotoModeAllowed, ReturnValue) == 0x000000, "Member 'PhxPlayerController_IsPhotoModeAllowed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerController.IsUsingStreamingVolumes
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerController_IsUsingStreamingVolumes final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerController_IsUsingStreamingVolumes) == 0x000001, "Wrong alignment on PhxPlayerController_IsUsingStreamingVolumes");
static_assert(sizeof(PhxPlayerController_IsUsingStreamingVolumes) == 0x000001, "Wrong size on PhxPlayerController_IsUsingStreamingVolumes");
static_assert(offsetof(PhxPlayerController_IsUsingStreamingVolumes, ReturnValue) == 0x000000, "Member 'PhxPlayerController_IsUsingStreamingVolumes::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHitmaskComponent.RenderHit
// 0x0018 (0x0018 - 0x0000)
struct PhxHitmaskComponent_RenderHit final
{
public:
	struct FVector                                Position;                                          // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BoneName;                                          // 0x000C(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHitmaskComponent_RenderHit) == 0x000004, "Wrong alignment on PhxHitmaskComponent_RenderHit");
static_assert(sizeof(PhxHitmaskComponent_RenderHit) == 0x000018, "Wrong size on PhxHitmaskComponent_RenderHit");
static_assert(offsetof(PhxHitmaskComponent_RenderHit, Position) == 0x000000, "Member 'PhxHitmaskComponent_RenderHit::Position' has a wrong offset!");
static_assert(offsetof(PhxHitmaskComponent_RenderHit, BoneName) == 0x00000C, "Member 'PhxHitmaskComponent_RenderHit::BoneName' has a wrong offset!");
static_assert(offsetof(PhxHitmaskComponent_RenderHit, Damage) == 0x000014, "Member 'PhxHitmaskComponent_RenderHit::Damage' has a wrong offset!");

// Function Phoenix.PhxMovementSpline.JumpToSplineDistance
// 0x0004 (0x0004 - 0x0000)
struct PhxMovementSpline_JumpToSplineDistance final
{
public:
	float                                         InDistanceAlongSpline;                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMovementSpline_JumpToSplineDistance) == 0x000004, "Wrong alignment on PhxMovementSpline_JumpToSplineDistance");
static_assert(sizeof(PhxMovementSpline_JumpToSplineDistance) == 0x000004, "Wrong size on PhxMovementSpline_JumpToSplineDistance");
static_assert(offsetof(PhxMovementSpline_JumpToSplineDistance, InDistanceAlongSpline) == 0x000000, "Member 'PhxMovementSpline_JumpToSplineDistance::InDistanceAlongSpline' has a wrong offset!");

// Function Phoenix.PhxMovementSpline.JumpToSplinePointActor
// 0x0008 (0x0008 - 0x0000)
struct PhxMovementSpline_JumpToSplinePointActor final
{
public:
	class APhxMovementSplinePoint*                InSplinePoint;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMovementSpline_JumpToSplinePointActor) == 0x000008, "Wrong alignment on PhxMovementSpline_JumpToSplinePointActor");
static_assert(sizeof(PhxMovementSpline_JumpToSplinePointActor) == 0x000008, "Wrong size on PhxMovementSpline_JumpToSplinePointActor");
static_assert(offsetof(PhxMovementSpline_JumpToSplinePointActor, InSplinePoint) == 0x000000, "Member 'PhxMovementSpline_JumpToSplinePointActor::InSplinePoint' has a wrong offset!");

// Function Phoenix.PhxMovementSpline.JumpToSplinePointIndex
// 0x0004 (0x0004 - 0x0000)
struct PhxMovementSpline_JumpToSplinePointIndex final
{
public:
	int32                                         InPointIndex;                                      // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMovementSpline_JumpToSplinePointIndex) == 0x000004, "Wrong alignment on PhxMovementSpline_JumpToSplinePointIndex");
static_assert(sizeof(PhxMovementSpline_JumpToSplinePointIndex) == 0x000004, "Wrong size on PhxMovementSpline_JumpToSplinePointIndex");
static_assert(offsetof(PhxMovementSpline_JumpToSplinePointIndex, InPointIndex) == 0x000000, "Member 'PhxMovementSpline_JumpToSplinePointIndex::InPointIndex' has a wrong offset!");

// Function Phoenix.PhxMovementSpline.SetMovementLoopBounds
// 0x0010 (0x0010 - 0x0000)
struct PhxMovementSpline_SetMovementLoopBounds final
{
public:
	struct FFloatRange                            InRange;                                           // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMovementSpline_SetMovementLoopBounds) == 0x000004, "Wrong alignment on PhxMovementSpline_SetMovementLoopBounds");
static_assert(sizeof(PhxMovementSpline_SetMovementLoopBounds) == 0x000010, "Wrong size on PhxMovementSpline_SetMovementLoopBounds");
static_assert(offsetof(PhxMovementSpline_SetMovementLoopBounds, InRange) == 0x000000, "Member 'PhxMovementSpline_SetMovementLoopBounds::InRange' has a wrong offset!");

// Function Phoenix.PhxMovementSpline.SetShouldLoopSplineMovement
// 0x0001 (0x0001 - 0x0000)
struct PhxMovementSpline_SetShouldLoopSplineMovement final
{
public:
	bool                                          bShouldLoopSplineMovement;                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMovementSpline_SetShouldLoopSplineMovement) == 0x000001, "Wrong alignment on PhxMovementSpline_SetShouldLoopSplineMovement");
static_assert(sizeof(PhxMovementSpline_SetShouldLoopSplineMovement) == 0x000001, "Wrong size on PhxMovementSpline_SetShouldLoopSplineMovement");
static_assert(offsetof(PhxMovementSpline_SetShouldLoopSplineMovement, bShouldLoopSplineMovement) == 0x000000, "Member 'PhxMovementSpline_SetShouldLoopSplineMovement::bShouldLoopSplineMovement' has a wrong offset!");

// Function Phoenix.PhxMovementSpline.StartMovement
// 0x0008 (0x0008 - 0x0000)
struct PhxMovementSpline_StartMovement final
{
public:
	class AActor*                                 InMoveActor;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMovementSpline_StartMovement) == 0x000008, "Wrong alignment on PhxMovementSpline_StartMovement");
static_assert(sizeof(PhxMovementSpline_StartMovement) == 0x000008, "Wrong size on PhxMovementSpline_StartMovement");
static_assert(offsetof(PhxMovementSpline_StartMovement, InMoveActor) == 0x000000, "Member 'PhxMovementSpline_StartMovement::InMoveActor' has a wrong offset!");

// Function Phoenix.PhxMovementSpline.GetCurrentMovementSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxMovementSpline_GetCurrentMovementSpeed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMovementSpline_GetCurrentMovementSpeed) == 0x000004, "Wrong alignment on PhxMovementSpline_GetCurrentMovementSpeed");
static_assert(sizeof(PhxMovementSpline_GetCurrentMovementSpeed) == 0x000004, "Wrong size on PhxMovementSpline_GetCurrentMovementSpeed");
static_assert(offsetof(PhxMovementSpline_GetCurrentMovementSpeed, ReturnValue) == 0x000000, "Member 'PhxMovementSpline_GetCurrentMovementSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPhysicalMovementSpline.RegisterBaseMovementCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxPhysicalMovementSpline_RegisterBaseMovementCharacter final
{
public:
	class ACharacter*                             BaseMovementCharacter;                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPhysicalMovementSpline_RegisterBaseMovementCharacter) == 0x000008, "Wrong alignment on PhxPhysicalMovementSpline_RegisterBaseMovementCharacter");
static_assert(sizeof(PhxPhysicalMovementSpline_RegisterBaseMovementCharacter) == 0x000008, "Wrong size on PhxPhysicalMovementSpline_RegisterBaseMovementCharacter");
static_assert(offsetof(PhxPhysicalMovementSpline_RegisterBaseMovementCharacter, BaseMovementCharacter) == 0x000000, "Member 'PhxPhysicalMovementSpline_RegisterBaseMovementCharacter::BaseMovementCharacter' has a wrong offset!");

// Function Phoenix.PhxPhysicalMovementSpline.UnregisterBaseMovementCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxPhysicalMovementSpline_UnregisterBaseMovementCharacter final
{
public:
	class ACharacter*                             BaseMovementCharacter;                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPhysicalMovementSpline_UnregisterBaseMovementCharacter) == 0x000008, "Wrong alignment on PhxPhysicalMovementSpline_UnregisterBaseMovementCharacter");
static_assert(sizeof(PhxPhysicalMovementSpline_UnregisterBaseMovementCharacter) == 0x000008, "Wrong size on PhxPhysicalMovementSpline_UnregisterBaseMovementCharacter");
static_assert(offsetof(PhxPhysicalMovementSpline_UnregisterBaseMovementCharacter, BaseMovementCharacter) == 0x000000, "Member 'PhxPhysicalMovementSpline_UnregisterBaseMovementCharacter::BaseMovementCharacter' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.GetNumEnemiesAwareOfPlayerOfType
// 0x000C (0x000C - 0x0000)
struct PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType final
{
public:
	struct FGameplayTag                           CharacterTag;                                      // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType) == 0x000004, "Wrong alignment on PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType");
static_assert(sizeof(PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType) == 0x00000C, "Wrong size on PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType");
static_assert(offsetof(PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType, CharacterTag) == 0x000000, "Member 'PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType::CharacterTag' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType, ReturnValue) == 0x000008, "Member 'PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAIBodyPartsKilled
// 0x0020 (0x0020 - 0x0000)
struct PhxAIGameStateManager_HandleAIBodyPartsKilled final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<EPhxBodyPartType>                      BodyPartsKilled;                                   // 0x0008(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
	class AActor*                                 InstigatorActor;                                   // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAIBodyPartsKilled) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAIBodyPartsKilled");
static_assert(sizeof(PhxAIGameStateManager_HandleAIBodyPartsKilled) == 0x000020, "Wrong size on PhxAIGameStateManager_HandleAIBodyPartsKilled");
static_assert(offsetof(PhxAIGameStateManager_HandleAIBodyPartsKilled, Character) == 0x000000, "Member 'PhxAIGameStateManager_HandleAIBodyPartsKilled::Character' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleAIBodyPartsKilled, BodyPartsKilled) == 0x000008, "Member 'PhxAIGameStateManager_HandleAIBodyPartsKilled::BodyPartsKilled' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleAIBodyPartsKilled, InstigatorActor) == 0x000018, "Member 'PhxAIGameStateManager_HandleAIBodyPartsKilled::InstigatorActor' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAIDestroyed
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameStateManager_HandleAIDestroyed final
{
public:
	class AActor*                                 DestroyedActor;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAIDestroyed) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAIDestroyed");
static_assert(sizeof(PhxAIGameStateManager_HandleAIDestroyed) == 0x000008, "Wrong size on PhxAIGameStateManager_HandleAIDestroyed");
static_assert(offsetof(PhxAIGameStateManager_HandleAIDestroyed, DestroyedActor) == 0x000000, "Member 'PhxAIGameStateManager_HandleAIDestroyed::DestroyedActor' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAIGRPGrabbed
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameStateManager_HandleAIGRPGrabbed final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAIGRPGrabbed) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAIGRPGrabbed");
static_assert(sizeof(PhxAIGameStateManager_HandleAIGRPGrabbed) == 0x000008, "Wrong size on PhxAIGameStateManager_HandleAIGRPGrabbed");
static_assert(offsetof(PhxAIGameStateManager_HandleAIGRPGrabbed, Character) == 0x000000, "Member 'PhxAIGameStateManager_HandleAIGRPGrabbed::Character' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAIKilledByHazard
// 0x0010 (0x0010 - 0x0000)
struct PhxAIGameStateManager_HandleAIKilledByHazard final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AEnvironmentalHazard*                   HazardActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAIKilledByHazard) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAIKilledByHazard");
static_assert(sizeof(PhxAIGameStateManager_HandleAIKilledByHazard) == 0x000010, "Wrong size on PhxAIGameStateManager_HandleAIKilledByHazard");
static_assert(offsetof(PhxAIGameStateManager_HandleAIKilledByHazard, Character) == 0x000000, "Member 'PhxAIGameStateManager_HandleAIKilledByHazard::Character' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleAIKilledByHazard, HazardActor) == 0x000008, "Member 'PhxAIGameStateManager_HandleAIKilledByHazard::HazardActor' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAIKilledByMeleeWeapon
// 0x0018 (0x0018 - 0x0000)
struct PhxAIGameStateManager_HandleAIKilledByMeleeWeapon final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AMeleeWeapon*                           Weapon;                                            // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxMeleeAttackDefinition*              AttackDef;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAIKilledByMeleeWeapon) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAIKilledByMeleeWeapon");
static_assert(sizeof(PhxAIGameStateManager_HandleAIKilledByMeleeWeapon) == 0x000018, "Wrong size on PhxAIGameStateManager_HandleAIKilledByMeleeWeapon");
static_assert(offsetof(PhxAIGameStateManager_HandleAIKilledByMeleeWeapon, Character) == 0x000000, "Member 'PhxAIGameStateManager_HandleAIKilledByMeleeWeapon::Character' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleAIKilledByMeleeWeapon, Weapon) == 0x000008, "Member 'PhxAIGameStateManager_HandleAIKilledByMeleeWeapon::Weapon' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleAIKilledByMeleeWeapon, AttackDef) == 0x000010, "Member 'PhxAIGameStateManager_HandleAIKilledByMeleeWeapon::AttackDef' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAILimboBegin
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameStateManager_HandleAILimboBegin final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAILimboBegin) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAILimboBegin");
static_assert(sizeof(PhxAIGameStateManager_HandleAILimboBegin) == 0x000008, "Wrong size on PhxAIGameStateManager_HandleAILimboBegin");
static_assert(offsetof(PhxAIGameStateManager_HandleAILimboBegin, Character) == 0x000000, "Member 'PhxAIGameStateManager_HandleAILimboBegin::Character' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAIMutateBegin
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameStateManager_HandleAIMutateBegin final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAIMutateBegin) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAIMutateBegin");
static_assert(sizeof(PhxAIGameStateManager_HandleAIMutateBegin) == 0x000008, "Wrong size on PhxAIGameStateManager_HandleAIMutateBegin");
static_assert(offsetof(PhxAIGameStateManager_HandleAIMutateBegin, Character) == 0x000000, "Member 'PhxAIGameStateManager_HandleAIMutateBegin::Character' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAIPostDeathBegin
// 0x0018 (0x0018 - 0x0000)
struct PhxAIGameStateManager_HandleAIPostDeathBegin final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAIPostDeathBegin) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAIPostDeathBegin");
static_assert(sizeof(PhxAIGameStateManager_HandleAIPostDeathBegin) == 0x000018, "Wrong size on PhxAIGameStateManager_HandleAIPostDeathBegin");
static_assert(offsetof(PhxAIGameStateManager_HandleAIPostDeathBegin, DeadCharacter) == 0x000000, "Member 'PhxAIGameStateManager_HandleAIPostDeathBegin::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleAIPostDeathBegin, KillerActor) == 0x000008, "Member 'PhxAIGameStateManager_HandleAIPostDeathBegin::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleAIPostDeathBegin, KillerController) == 0x000010, "Member 'PhxAIGameStateManager_HandleAIPostDeathBegin::KillerController' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAIResurrectBegin
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameStateManager_HandleAIResurrectBegin final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAIResurrectBegin) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAIResurrectBegin");
static_assert(sizeof(PhxAIGameStateManager_HandleAIResurrectBegin) == 0x000008, "Wrong size on PhxAIGameStateManager_HandleAIResurrectBegin");
static_assert(offsetof(PhxAIGameStateManager_HandleAIResurrectBegin, Character) == 0x000000, "Member 'PhxAIGameStateManager_HandleAIResurrectBegin::Character' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleAIVirusBegin
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameStateManager_HandleAIVirusBegin final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleAIVirusBegin) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleAIVirusBegin");
static_assert(sizeof(PhxAIGameStateManager_HandleAIVirusBegin) == 0x000008, "Wrong size on PhxAIGameStateManager_HandleAIVirusBegin");
static_assert(offsetof(PhxAIGameStateManager_HandleAIVirusBegin, Character) == 0x000000, "Member 'PhxAIGameStateManager_HandleAIVirusBegin::Character' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.HandleTakeAnyDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxAIGameStateManager_HandleTakeAnyDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_HandleTakeAnyDamage) == 0x000008, "Wrong alignment on PhxAIGameStateManager_HandleTakeAnyDamage");
static_assert(sizeof(PhxAIGameStateManager_HandleTakeAnyDamage) == 0x000028, "Wrong size on PhxAIGameStateManager_HandleTakeAnyDamage");
static_assert(offsetof(PhxAIGameStateManager_HandleTakeAnyDamage, DamagedActor) == 0x000000, "Member 'PhxAIGameStateManager_HandleTakeAnyDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleTakeAnyDamage, Damage) == 0x000008, "Member 'PhxAIGameStateManager_HandleTakeAnyDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleTakeAnyDamage, DamageType) == 0x000010, "Member 'PhxAIGameStateManager_HandleTakeAnyDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleTakeAnyDamage, InstigatedBy) == 0x000018, "Member 'PhxAIGameStateManager_HandleTakeAnyDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAIGameStateManager_HandleTakeAnyDamage, DamageCauser) == 0x000020, "Member 'PhxAIGameStateManager_HandleTakeAnyDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.GetGameState
// 0x0001 (0x0001 - 0x0000)
struct PhxAIGameStateManager_GetGameState final
{
public:
	EPhxAIGameState                               ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_GetGameState) == 0x000001, "Wrong alignment on PhxAIGameStateManager_GetGameState");
static_assert(sizeof(PhxAIGameStateManager_GetGameState) == 0x000001, "Wrong size on PhxAIGameStateManager_GetGameState");
static_assert(offsetof(PhxAIGameStateManager_GetGameState, ReturnValue) == 0x000000, "Member 'PhxAIGameStateManager_GetGameState::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.GetNumActiveEnemies
// 0x0004 (0x0004 - 0x0000)
struct PhxAIGameStateManager_GetNumActiveEnemies final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_GetNumActiveEnemies) == 0x000004, "Wrong alignment on PhxAIGameStateManager_GetNumActiveEnemies");
static_assert(sizeof(PhxAIGameStateManager_GetNumActiveEnemies) == 0x000004, "Wrong size on PhxAIGameStateManager_GetNumActiveEnemies");
static_assert(offsetof(PhxAIGameStateManager_GetNumActiveEnemies, ReturnValue) == 0x000000, "Member 'PhxAIGameStateManager_GetNumActiveEnemies::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.IsLastEnemyTargetingPlayer
// 0x0001 (0x0001 - 0x0000)
struct PhxAIGameStateManager_IsLastEnemyTargetingPlayer final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_IsLastEnemyTargetingPlayer) == 0x000001, "Wrong alignment on PhxAIGameStateManager_IsLastEnemyTargetingPlayer");
static_assert(sizeof(PhxAIGameStateManager_IsLastEnemyTargetingPlayer) == 0x000001, "Wrong size on PhxAIGameStateManager_IsLastEnemyTargetingPlayer");
static_assert(offsetof(PhxAIGameStateManager_IsLastEnemyTargetingPlayer, ReturnValue) == 0x000000, "Member 'PhxAIGameStateManager_IsLastEnemyTargetingPlayer::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIGameStateManager.K2_GetActiveEnemies
// 0x0010 (0x0010 - 0x0000)
struct PhxAIGameStateManager_K2_GetActiveEnemies final
{
public:
	TArray<class APhxAICharacter*>                ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameStateManager_K2_GetActiveEnemies) == 0x000008, "Wrong alignment on PhxAIGameStateManager_K2_GetActiveEnemies");
static_assert(sizeof(PhxAIGameStateManager_K2_GetActiveEnemies) == 0x000010, "Wrong size on PhxAIGameStateManager_K2_GetActiveEnemies");
static_assert(offsetof(PhxAIGameStateManager_K2_GetActiveEnemies, ReturnValue) == 0x000000, "Member 'PhxAIGameStateManager_K2_GetActiveEnemies::ReturnValue' has a wrong offset!");

// Function Phoenix.MotionMatchCostRetriever.OnAISpawned
// 0x0008 (0x0008 - 0x0000)
struct MotionMatchCostRetriever_OnAISpawned final
{
public:
	class ACharacter*                             Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MotionMatchCostRetriever_OnAISpawned) == 0x000008, "Wrong alignment on MotionMatchCostRetriever_OnAISpawned");
static_assert(sizeof(MotionMatchCostRetriever_OnAISpawned) == 0x000008, "Wrong size on MotionMatchCostRetriever_OnAISpawned");
static_assert(offsetof(MotionMatchCostRetriever_OnAISpawned, Character) == 0x000000, "Member 'MotionMatchCostRetriever_OnAISpawned::Character' has a wrong offset!");

// Function Phoenix.MotionMatchCostRetriever.Reset
// 0x0001 (0x0001 - 0x0000)
struct MotionMatchCostRetriever_Reset final
{
public:
	bool                                          TestRunning;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MotionMatchCostRetriever_Reset) == 0x000001, "Wrong alignment on MotionMatchCostRetriever_Reset");
static_assert(sizeof(MotionMatchCostRetriever_Reset) == 0x000001, "Wrong size on MotionMatchCostRetriever_Reset");
static_assert(offsetof(MotionMatchCostRetriever_Reset, TestRunning) == 0x000000, "Member 'MotionMatchCostRetriever_Reset::TestRunning' has a wrong offset!");

// Function Phoenix.MotionMatchCostRetriever.UpdateCost
// 0x0001 (0x0001 - 0x0000)
struct MotionMatchCostRetriever_UpdateCost final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MotionMatchCostRetriever_UpdateCost) == 0x000001, "Wrong alignment on MotionMatchCostRetriever_UpdateCost");
static_assert(sizeof(MotionMatchCostRetriever_UpdateCost) == 0x000001, "Wrong size on MotionMatchCostRetriever_UpdateCost");
static_assert(offsetof(MotionMatchCostRetriever_UpdateCost, ReturnValue) == 0x000000, "Member 'MotionMatchCostRetriever_UpdateCost::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundStateLibrary.GetActiveStates
// 0x0050 (0x0050 - 0x0000)
struct PhxSoundStateLibrary_GetActiveStates final
{
public:
	TSet<class FString>                           ReturnValue;                                       // 0x0000(0x0050)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundStateLibrary_GetActiveStates) == 0x000008, "Wrong alignment on PhxSoundStateLibrary_GetActiveStates");
static_assert(sizeof(PhxSoundStateLibrary_GetActiveStates) == 0x000050, "Wrong size on PhxSoundStateLibrary_GetActiveStates");
static_assert(offsetof(PhxSoundStateLibrary_GetActiveStates, ReturnValue) == 0x000000, "Member 'PhxSoundStateLibrary_GetActiveStates::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundStateLibrary.ResetStates
// 0x00A0 (0x00A0 - 0x0000)
struct PhxSoundStateLibrary_ResetStates final
{
public:
	TSet<class UAkStateValue*>                    KeepValues;                                        // 0x0000(0x0050)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	TSet<class FName>                             KeepGroupNames;                                    // 0x0050(0x0050)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundStateLibrary_ResetStates) == 0x000008, "Wrong alignment on PhxSoundStateLibrary_ResetStates");
static_assert(sizeof(PhxSoundStateLibrary_ResetStates) == 0x0000A0, "Wrong size on PhxSoundStateLibrary_ResetStates");
static_assert(offsetof(PhxSoundStateLibrary_ResetStates, KeepValues) == 0x000000, "Member 'PhxSoundStateLibrary_ResetStates::KeepValues' has a wrong offset!");
static_assert(offsetof(PhxSoundStateLibrary_ResetStates, KeepGroupNames) == 0x000050, "Member 'PhxSoundStateLibrary_ResetStates::KeepGroupNames' has a wrong offset!");

// Function Phoenix.PauseMenuState.ScreenCreated
// 0x0008 (0x0008 - 0x0000)
struct PauseMenuState_ScreenCreated final
{
public:
	class USDSScreenWidget*                       NewScreen;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PauseMenuState_ScreenCreated) == 0x000008, "Wrong alignment on PauseMenuState_ScreenCreated");
static_assert(sizeof(PauseMenuState_ScreenCreated) == 0x000008, "Wrong size on PauseMenuState_ScreenCreated");
static_assert(offsetof(PauseMenuState_ScreenCreated, NewScreen) == 0x000000, "Member 'PauseMenuState_ScreenCreated::NewScreen' has a wrong offset!");

// Function Phoenix.PauseMenuWidget.SetSelection
// 0x0008 (0x0008 - 0x0000)
struct PauseMenuWidget_SetSelection final
{
public:
	int32                                         ButtonIndex;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bPlayAnimation;                                    // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PauseMenuWidget_SetSelection) == 0x000004, "Wrong alignment on PauseMenuWidget_SetSelection");
static_assert(sizeof(PauseMenuWidget_SetSelection) == 0x000008, "Wrong size on PauseMenuWidget_SetSelection");
static_assert(offsetof(PauseMenuWidget_SetSelection, ButtonIndex) == 0x000000, "Member 'PauseMenuWidget_SetSelection::ButtonIndex' has a wrong offset!");
static_assert(offsetof(PauseMenuWidget_SetSelection, bPlayAnimation) == 0x000004, "Member 'PauseMenuWidget_SetSelection::bPlayAnimation' has a wrong offset!");

// Function Phoenix.PauseMenuWidget.GetLevelSelectWidget
// 0x0008 (0x0008 - 0x0000)
struct PauseMenuWidget_GetLevelSelectWidget final
{
public:
	class ULevelSelectWidget*                     ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PauseMenuWidget_GetLevelSelectWidget) == 0x000008, "Wrong alignment on PauseMenuWidget_GetLevelSelectWidget");
static_assert(sizeof(PauseMenuWidget_GetLevelSelectWidget) == 0x000008, "Wrong size on PauseMenuWidget_GetLevelSelectWidget");
static_assert(offsetof(PauseMenuWidget_GetLevelSelectWidget, ReturnValue) == 0x000000, "Member 'PauseMenuWidget_GetLevelSelectWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.PauseMenuWidget.GetOptionsWidget
// 0x0008 (0x0008 - 0x0000)
struct PauseMenuWidget_GetOptionsWidget final
{
public:
	class UOptionsWidget*                         ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PauseMenuWidget_GetOptionsWidget) == 0x000008, "Wrong alignment on PauseMenuWidget_GetOptionsWidget");
static_assert(sizeof(PauseMenuWidget_GetOptionsWidget) == 0x000008, "Wrong size on PauseMenuWidget_GetOptionsWidget");
static_assert(offsetof(PauseMenuWidget_GetOptionsWidget, ReturnValue) == 0x000000, "Member 'PauseMenuWidget_GetOptionsWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToActorForce.ApplyPhxRootMotionMoveToActorForce
// 0x0058 (0x0058 - 0x0000)
struct PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce final
{
public:
	struct FPhxRootMotionMoveToActorSettings      MoveToActorSettings;                               // 0x0000(0x0050)(Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
	class UPhxAbilityTask_ApplyRootMotionMoveToActorForce* ReturnValue;                              // 0x0050(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce) == 0x000008, "Wrong alignment on PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce");
static_assert(sizeof(PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce) == 0x000058, "Wrong size on PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce, MoveToActorSettings) == 0x000000, "Member 'PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce::MoveToActorSettings' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce, ReturnValue) == 0x000050, "Member 'PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EncounterGroupActions.DestroyAllCorpses
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_EncounterGroupActions* ReturnValue;                                  // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses");
static_assert(sizeof(PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses) == 0x000010, "Wrong size on PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses");
static_assert(offsetof(PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EncounterGroupActions.EndEncounterGroup
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_EncounterGroupActions* ReturnValue;                                  // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup");
static_assert(sizeof(PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup) == 0x000010, "Wrong size on PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup");
static_assert(offsetof(PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EncounterGroupActions.FinishEncounterGroup
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_EncounterGroupActions* ReturnValue;                                  // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup");
static_assert(sizeof(PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup) == 0x000010, "Wrong size on PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup");
static_assert(offsetof(PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EncounterGroupActions.KillEncounterGroup
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_EncounterGroupActions* ReturnValue;                                  // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup");
static_assert(sizeof(PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup) == 0x000010, "Wrong size on PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup");
static_assert(offsetof(PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToDynamicForce.ApplyPhxRootMotionMoveToDynamicForce
// 0x0050 (0x0050 - 0x0000)
struct PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce final
{
public:
	struct FPhxRootMotionMoveToDynamicForceSettings MoveToLocationSettings;                          // 0x0000(0x0044)(Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAbilityTask_ApplyRootMotionMoveToDynamicForce* ReturnValue;                            // 0x0048(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce) == 0x000008, "Wrong alignment on PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce");
static_assert(sizeof(PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce) == 0x000050, "Wrong size on PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce, MoveToLocationSettings) == 0x000000, "Member 'PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce::MoveToLocationSettings' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce, ReturnValue) == 0x000048, "Member 'PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToForce.ApplyPhxRootMotionMoveToForce
// 0x0070 (0x0070 - 0x0000)
struct PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce final
{
public:
	struct FPhxRootMotionMoveToSettings           RootMotionMoveToSettings;                          // 0x0000(0x0060)(Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
	class UPhxAbilityTask_ApplyRootMotionMoveToForce* ReturnValue;                                   // 0x0060(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_68[0x8];                                       // 0x0068(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce) == 0x000010, "Wrong alignment on PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce");
static_assert(sizeof(PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce) == 0x000070, "Wrong size on PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce, RootMotionMoveToSettings) == 0x000000, "Member 'PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce::RootMotionMoveToSettings' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce, ReturnValue) == 0x000060, "Member 'PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToForceArc.ApplyPhxRootMotionMoveToForceArc
// 0x0070 (0x0070 - 0x0000)
struct PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc final
{
public:
	struct FPhxRootMotionMoveToArcSettings        RootMotionMoveToSettings;                          // 0x0000(0x0060)(Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
	class UPhxAbilityTask_ApplyRootMotionMoveToForceArc* ReturnValue;                                // 0x0060(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_68[0x8];                                       // 0x0068(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc) == 0x000010, "Wrong alignment on PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc");
static_assert(sizeof(PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc) == 0x000070, "Wrong size on PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc, RootMotionMoveToSettings) == 0x000000, "Member 'PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc::RootMotionMoveToSettings' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc, ReturnValue) == 0x000060, "Member 'PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToForceXY.ApplyPhxRootMotionMoveToForceXY
// 0x0040 (0x0040 - 0x0000)
struct PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY final
{
public:
	struct FPhxRootMotionMoveToLocationXYSettings MoveToLocationSettings;                            // 0x0000(0x0034)(Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAbilityTask_ApplyRootMotionMoveToForceXY* ReturnValue;                                 // 0x0038(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY) == 0x000008, "Wrong alignment on PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY");
static_assert(sizeof(PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY) == 0x000040, "Wrong size on PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY, MoveToLocationSettings) == 0x000000, "Member 'PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY::MoveToLocationSettings' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY, ReturnValue) == 0x000038, "Member 'PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_BeginEncounterGroup.BeginEncounterGroup
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_BeginEncounterGroup* ReturnValue;                                    // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup");
static_assert(sizeof(PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup) == 0x000010, "Wrong size on PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup");
static_assert(offsetof(PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_BeginEncounterGroup.ForceBeginEncounterGroup
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_BeginEncounterGroup* ReturnValue;                                    // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup");
static_assert(sizeof(PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup) == 0x000010, "Wrong size on PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup");
static_assert(offsetof(PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_BeginEncounterGroup.OnEncounterGroupStreamedOut
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintAction_BeginEncounterGroup_OnEncounterGroupStreamedOut final
{
public:
	class APhxAIEncounterGroup*                   InEncounterGroup;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_BeginEncounterGroup_OnEncounterGroupStreamedOut) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_BeginEncounterGroup_OnEncounterGroupStreamedOut");
static_assert(sizeof(PhxAIBlueprintAction_BeginEncounterGroup_OnEncounterGroupStreamedOut) == 0x000008, "Wrong size on PhxAIBlueprintAction_BeginEncounterGroup_OnEncounterGroupStreamedOut");
static_assert(offsetof(PhxAIBlueprintAction_BeginEncounterGroup_OnEncounterGroupStreamedOut, InEncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_BeginEncounterGroup_OnEncounterGroupStreamedOut::InEncounterGroup' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_BeginEncounterGroup.OnLastWaveCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted final
{
public:
	class APhxAIEncounterGroup*                   InEncounterGroup;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIEncounterGroupWaveDescriptor*     InWaveDescriptor;                                  // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted");
static_assert(sizeof(PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted) == 0x000010, "Wrong size on PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted");
static_assert(offsetof(PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted, InEncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted::InEncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted, InWaveDescriptor) == 0x000008, "Member 'PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted::InWaveDescriptor' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_ExitEncounterNetwork.ExitEncounterNetwork
// 0x0020 (0x0020 - 0x0000)
struct PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIEncounterNetwork*                 EncounterNetwork;                                  // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTeleport;                                         // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAIBlueprintAction_ExitEncounterNetwork* ReturnValue;                                   // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork");
static_assert(sizeof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork) == 0x000020, "Wrong size on PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork, Character) == 0x000000, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork, EncounterNetwork) == 0x000008, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork::EncounterNetwork' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork, bTeleport) == 0x000010, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork::bTeleport' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork, ReturnValue) == 0x000018, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_ExitEncounterNetwork.ExitEncounterNetworkAtNode
// 0x0020 (0x0020 - 0x0000)
struct PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIEncounterNetworkTraversalNode*    Exit;                                              // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTeleport;                                         // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAIBlueprintAction_ExitEncounterNetwork* ReturnValue;                                   // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode");
static_assert(sizeof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode) == 0x000020, "Wrong size on PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode, Character) == 0x000000, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode, Exit) == 0x000008, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode::Exit' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode, bTeleport) == 0x000010, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode::bTeleport' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode, ReturnValue) == 0x000018, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_ExitEncounterNetwork.ExitEncounterNetworkGroup
// 0x0040 (0x0040 - 0x0000)
struct PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UPhxAICharacterDefinition> AICharacterDefinition;                           // 0x0008(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIEncounterNetwork*                 EncounterNetwork;                                  // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTeleport;                                         // 0x0038(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup");
static_assert(sizeof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup) == 0x000040, "Wrong size on PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup, AICharacterDefinition) == 0x000008, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup::AICharacterDefinition' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup, EncounterNetwork) == 0x000030, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup::EncounterNetwork' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup, bTeleport) == 0x000038, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup::bTeleport' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_ExitEncounterNetwork.HandleExitEncounterNetworkCompleted
// 0x0001 (0x0001 - 0x0000)
struct PhxAIBlueprintAction_ExitEncounterNetwork_HandleExitEncounterNetworkCompleted final
{
public:
	bool                                          bSuccess;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_ExitEncounterNetwork_HandleExitEncounterNetworkCompleted) == 0x000001, "Wrong alignment on PhxAIBlueprintAction_ExitEncounterNetwork_HandleExitEncounterNetworkCompleted");
static_assert(sizeof(PhxAIBlueprintAction_ExitEncounterNetwork_HandleExitEncounterNetworkCompleted) == 0x000001, "Wrong size on PhxAIBlueprintAction_ExitEncounterNetwork_HandleExitEncounterNetworkCompleted");
static_assert(offsetof(PhxAIBlueprintAction_ExitEncounterNetwork_HandleExitEncounterNetworkCompleted, bSuccess) == 0x000000, "Member 'PhxAIBlueprintAction_ExitEncounterNetwork_HandleExitEncounterNetworkCompleted::bSuccess' has a wrong offset!");

// Function Phoenix.PhxVehicleSimulationComponent.GetCurrentPosition
// 0x000C (0x000C - 0x0000)
struct PhxVehicleSimulationComponent_GetCurrentPosition final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehicleSimulationComponent_GetCurrentPosition) == 0x000004, "Wrong alignment on PhxVehicleSimulationComponent_GetCurrentPosition");
static_assert(sizeof(PhxVehicleSimulationComponent_GetCurrentPosition) == 0x00000C, "Wrong size on PhxVehicleSimulationComponent_GetCurrentPosition");
static_assert(offsetof(PhxVehicleSimulationComponent_GetCurrentPosition, ReturnValue) == 0x000000, "Member 'PhxVehicleSimulationComponent_GetCurrentPosition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxVehicleSimulationComponent.GetCurrentRotation
// 0x000C (0x000C - 0x0000)
struct PhxVehicleSimulationComponent_GetCurrentRotation final
{
public:
	struct FRotator                               ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehicleSimulationComponent_GetCurrentRotation) == 0x000004, "Wrong alignment on PhxVehicleSimulationComponent_GetCurrentRotation");
static_assert(sizeof(PhxVehicleSimulationComponent_GetCurrentRotation) == 0x00000C, "Wrong size on PhxVehicleSimulationComponent_GetCurrentRotation");
static_assert(offsetof(PhxVehicleSimulationComponent_GetCurrentRotation, ReturnValue) == 0x000000, "Member 'PhxVehicleSimulationComponent_GetCurrentRotation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxVehicleSimulationComponent.GetEngineSpeedRPM
// 0x0004 (0x0004 - 0x0000)
struct PhxVehicleSimulationComponent_GetEngineSpeedRPM final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehicleSimulationComponent_GetEngineSpeedRPM) == 0x000004, "Wrong alignment on PhxVehicleSimulationComponent_GetEngineSpeedRPM");
static_assert(sizeof(PhxVehicleSimulationComponent_GetEngineSpeedRPM) == 0x000004, "Wrong size on PhxVehicleSimulationComponent_GetEngineSpeedRPM");
static_assert(offsetof(PhxVehicleSimulationComponent_GetEngineSpeedRPM, ReturnValue) == 0x000000, "Member 'PhxVehicleSimulationComponent_GetEngineSpeedRPM::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxVehicleSimulationComponent.GetEngineTorque
// 0x0004 (0x0004 - 0x0000)
struct PhxVehicleSimulationComponent_GetEngineTorque final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehicleSimulationComponent_GetEngineTorque) == 0x000004, "Wrong alignment on PhxVehicleSimulationComponent_GetEngineTorque");
static_assert(sizeof(PhxVehicleSimulationComponent_GetEngineTorque) == 0x000004, "Wrong size on PhxVehicleSimulationComponent_GetEngineTorque");
static_assert(offsetof(PhxVehicleSimulationComponent_GetEngineTorque, ReturnValue) == 0x000000, "Member 'PhxVehicleSimulationComponent_GetEngineTorque::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxVehicleSimulationComponent.GetGear
// 0x0004 (0x0004 - 0x0000)
struct PhxVehicleSimulationComponent_GetGear final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehicleSimulationComponent_GetGear) == 0x000004, "Wrong alignment on PhxVehicleSimulationComponent_GetGear");
static_assert(sizeof(PhxVehicleSimulationComponent_GetGear) == 0x000004, "Wrong size on PhxVehicleSimulationComponent_GetGear");
static_assert(offsetof(PhxVehicleSimulationComponent_GetGear, ReturnValue) == 0x000000, "Member 'PhxVehicleSimulationComponent_GetGear::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxVehicleSimulationComponent.GetSpeedMPH
// 0x0004 (0x0004 - 0x0000)
struct PhxVehicleSimulationComponent_GetSpeedMPH final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehicleSimulationComponent_GetSpeedMPH) == 0x000004, "Wrong alignment on PhxVehicleSimulationComponent_GetSpeedMPH");
static_assert(sizeof(PhxVehicleSimulationComponent_GetSpeedMPH) == 0x000004, "Wrong size on PhxVehicleSimulationComponent_GetSpeedMPH");
static_assert(offsetof(PhxVehicleSimulationComponent_GetSpeedMPH, ReturnValue) == 0x000000, "Member 'PhxVehicleSimulationComponent_GetSpeedMPH::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxVehicleSimulationComponent.GetTractionForce
// 0x0004 (0x0004 - 0x0000)
struct PhxVehicleSimulationComponent_GetTractionForce final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehicleSimulationComponent_GetTractionForce) == 0x000004, "Wrong alignment on PhxVehicleSimulationComponent_GetTractionForce");
static_assert(sizeof(PhxVehicleSimulationComponent_GetTractionForce) == 0x000004, "Wrong size on PhxVehicleSimulationComponent_GetTractionForce");
static_assert(offsetof(PhxVehicleSimulationComponent_GetTractionForce, ReturnValue) == 0x000000, "Member 'PhxVehicleSimulationComponent_GetTractionForce::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacterAwarenessComponent.HandleOwnerDied
// 0x0020 (0x0020 - 0x0000)
struct PhxAICharacterAwarenessComponent_HandleOwnerDied final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAICharacterAwarenessComponent_HandleOwnerDied) == 0x000008, "Wrong alignment on PhxAICharacterAwarenessComponent_HandleOwnerDied");
static_assert(sizeof(PhxAICharacterAwarenessComponent_HandleOwnerDied) == 0x000020, "Wrong size on PhxAICharacterAwarenessComponent_HandleOwnerDied");
static_assert(offsetof(PhxAICharacterAwarenessComponent_HandleOwnerDied, DeadCharacter) == 0x000000, "Member 'PhxAICharacterAwarenessComponent_HandleOwnerDied::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAICharacterAwarenessComponent_HandleOwnerDied, KillerActor) == 0x000008, "Member 'PhxAICharacterAwarenessComponent_HandleOwnerDied::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAICharacterAwarenessComponent_HandleOwnerDied, KillerController) == 0x000010, "Member 'PhxAICharacterAwarenessComponent_HandleOwnerDied::KillerController' has a wrong offset!");
static_assert(offsetof(PhxAICharacterAwarenessComponent_HandleOwnerDied, KillingBlowHealthDelta) == 0x000018, "Member 'PhxAICharacterAwarenessComponent_HandleOwnerDied::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxLineBatchComponent.DrawNewLine
// 0x0030 (0x0030 - 0x0000)
struct PhxLineBatchComponent_DrawNewLine final
{
public:
	struct FVector                                StartLocation;                                     // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                EndLocation;                                       // 0x000C(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           Color;                                             // 0x0018(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         DepthPriority;                                     // 0x0028(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x3];                                       // 0x0029(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Thickness;                                         // 0x002C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLineBatchComponent_DrawNewLine) == 0x000004, "Wrong alignment on PhxLineBatchComponent_DrawNewLine");
static_assert(sizeof(PhxLineBatchComponent_DrawNewLine) == 0x000030, "Wrong size on PhxLineBatchComponent_DrawNewLine");
static_assert(offsetof(PhxLineBatchComponent_DrawNewLine, StartLocation) == 0x000000, "Member 'PhxLineBatchComponent_DrawNewLine::StartLocation' has a wrong offset!");
static_assert(offsetof(PhxLineBatchComponent_DrawNewLine, EndLocation) == 0x00000C, "Member 'PhxLineBatchComponent_DrawNewLine::EndLocation' has a wrong offset!");
static_assert(offsetof(PhxLineBatchComponent_DrawNewLine, Color) == 0x000018, "Member 'PhxLineBatchComponent_DrawNewLine::Color' has a wrong offset!");
static_assert(offsetof(PhxLineBatchComponent_DrawNewLine, DepthPriority) == 0x000028, "Member 'PhxLineBatchComponent_DrawNewLine::DepthPriority' has a wrong offset!");
static_assert(offsetof(PhxLineBatchComponent_DrawNewLine, Thickness) == 0x00002C, "Member 'PhxLineBatchComponent_DrawNewLine::Thickness' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_LockToGrabBone.OnCurrentMontageCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted final
{
public:
	class UAnimMontage*                           Montage;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInterrupted;                                      // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted) == 0x000008, "Wrong alignment on PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted");
static_assert(sizeof(PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted) == 0x000010, "Wrong size on PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted");
static_assert(offsetof(PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted, Montage) == 0x000000, "Member 'PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted::Montage' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted, bInterrupted) == 0x000008, "Member 'PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted::bInterrupted' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_LockToGrabBone.OnNewMontageStarted
// 0x0008 (0x0008 - 0x0000)
struct PhxAbilityTask_LockToGrabBone_OnNewMontageStarted final
{
public:
	class UAnimMontage*                           Montage;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_LockToGrabBone_OnNewMontageStarted) == 0x000008, "Wrong alignment on PhxAbilityTask_LockToGrabBone_OnNewMontageStarted");
static_assert(sizeof(PhxAbilityTask_LockToGrabBone_OnNewMontageStarted) == 0x000008, "Wrong size on PhxAbilityTask_LockToGrabBone_OnNewMontageStarted");
static_assert(offsetof(PhxAbilityTask_LockToGrabBone_OnNewMontageStarted, Montage) == 0x000000, "Member 'PhxAbilityTask_LockToGrabBone_OnNewMontageStarted::Montage' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_LockToGrabBone.ReceiveNotify
// 0x0008 (0x0008 - 0x0000)
struct PhxAbilityTask_LockToGrabBone_ReceiveNotify final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_LockToGrabBone_ReceiveNotify) == 0x000008, "Wrong alignment on PhxAbilityTask_LockToGrabBone_ReceiveNotify");
static_assert(sizeof(PhxAbilityTask_LockToGrabBone_ReceiveNotify) == 0x000008, "Wrong size on PhxAbilityTask_LockToGrabBone_ReceiveNotify");
static_assert(offsetof(PhxAbilityTask_LockToGrabBone_ReceiveNotify, Notify) == 0x000000, "Member 'PhxAbilityTask_LockToGrabBone_ReceiveNotify::Notify' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_RunAbility.OnAbilityFinished
// 0x000C (0x000C - 0x0000)
struct PhxAbilityTask_RunAbility_OnAbilityFinished final
{
public:
	struct FGameplayTag                           InTag;                                             // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NewCount;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_RunAbility_OnAbilityFinished) == 0x000004, "Wrong alignment on PhxAbilityTask_RunAbility_OnAbilityFinished");
static_assert(sizeof(PhxAbilityTask_RunAbility_OnAbilityFinished) == 0x00000C, "Wrong size on PhxAbilityTask_RunAbility_OnAbilityFinished");
static_assert(offsetof(PhxAbilityTask_RunAbility_OnAbilityFinished, InTag) == 0x000000, "Member 'PhxAbilityTask_RunAbility_OnAbilityFinished::InTag' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_RunAbility_OnAbilityFinished, NewCount) == 0x000008, "Member 'PhxAbilityTask_RunAbility_OnAbilityFinished::NewCount' has a wrong offset!");

// Function Phoenix.PhxAICharacterComponent.OnReceivedDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxAICharacterComponent_OnReceivedDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterComponent_OnReceivedDamage) == 0x000008, "Wrong alignment on PhxAICharacterComponent_OnReceivedDamage");
static_assert(sizeof(PhxAICharacterComponent_OnReceivedDamage) == 0x000028, "Wrong size on PhxAICharacterComponent_OnReceivedDamage");
static_assert(offsetof(PhxAICharacterComponent_OnReceivedDamage, DamagedActor) == 0x000000, "Member 'PhxAICharacterComponent_OnReceivedDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_OnReceivedDamage, Damage) == 0x000008, "Member 'PhxAICharacterComponent_OnReceivedDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_OnReceivedDamage, DamageType) == 0x000010, "Member 'PhxAICharacterComponent_OnReceivedDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_OnReceivedDamage, InstigatedBy) == 0x000018, "Member 'PhxAICharacterComponent_OnReceivedDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_OnReceivedDamage, DamageCauser) == 0x000020, "Member 'PhxAICharacterComponent_OnReceivedDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxAICharacterComponent.OnRecievedComboEnder
// 0x0010 (0x0010 - 0x0000)
struct PhxAICharacterComponent_OnRecievedComboEnder final
{
public:
	class APhxCharacter*                          Target;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxMeleeAttackDefinition*              ComboEndingAttack;                                 // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterComponent_OnRecievedComboEnder) == 0x000008, "Wrong alignment on PhxAICharacterComponent_OnRecievedComboEnder");
static_assert(sizeof(PhxAICharacterComponent_OnRecievedComboEnder) == 0x000010, "Wrong size on PhxAICharacterComponent_OnRecievedComboEnder");
static_assert(offsetof(PhxAICharacterComponent_OnRecievedComboEnder, Target) == 0x000000, "Member 'PhxAICharacterComponent_OnRecievedComboEnder::Target' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_OnRecievedComboEnder, ComboEndingAttack) == 0x000008, "Member 'PhxAICharacterComponent_OnRecievedComboEnder::ComboEndingAttack' has a wrong offset!");

// Function Phoenix.PhxPlatformTexturePack.GetControllerKeyIcon
// 0x0010 (0x0010 - 0x0000)
struct PhxPlatformTexturePack_GetControllerKeyIcon final
{
public:
	EPhxControllerKeys                            InKey;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UTexture*                               ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlatformTexturePack_GetControllerKeyIcon) == 0x000008, "Wrong alignment on PhxPlatformTexturePack_GetControllerKeyIcon");
static_assert(sizeof(PhxPlatformTexturePack_GetControllerKeyIcon) == 0x000010, "Wrong size on PhxPlatformTexturePack_GetControllerKeyIcon");
static_assert(offsetof(PhxPlatformTexturePack_GetControllerKeyIcon, InKey) == 0x000000, "Member 'PhxPlatformTexturePack_GetControllerKeyIcon::InKey' has a wrong offset!");
static_assert(offsetof(PhxPlatformTexturePack_GetControllerKeyIcon, ReturnValue) == 0x000008, "Member 'PhxPlatformTexturePack_GetControllerKeyIcon::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPerformanceProfilingActor.LogPerformanceProfilingDataToFile
// 0x0018 (0x0018 - 0x0000)
struct PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile final
{
public:
	class FString                                 PerfIdentifier;                                    // 0x0000(0x0010)(ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile) == 0x000008, "Wrong alignment on PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile");
static_assert(sizeof(PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile) == 0x000018, "Wrong size on PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile");
static_assert(offsetof(PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile, PerfIdentifier) == 0x000000, "Member 'PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile::PerfIdentifier' has a wrong offset!");
static_assert(offsetof(PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile, ReturnValue) == 0x000010, "Member 'PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPerformanceProfilingActor.SavePerformanceDataPoint
// 0x0010 (0x0010 - 0x0000)
struct PhxPerformanceProfilingActor_SavePerformanceDataPoint final
{
public:
	class FString                                 Identifier;                                        // 0x0000(0x0010)(ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPerformanceProfilingActor_SavePerformanceDataPoint) == 0x000008, "Wrong alignment on PhxPerformanceProfilingActor_SavePerformanceDataPoint");
static_assert(sizeof(PhxPerformanceProfilingActor_SavePerformanceDataPoint) == 0x000010, "Wrong size on PhxPerformanceProfilingActor_SavePerformanceDataPoint");
static_assert(offsetof(PhxPerformanceProfilingActor_SavePerformanceDataPoint, Identifier) == 0x000000, "Member 'PhxPerformanceProfilingActor_SavePerformanceDataPoint::Identifier' has a wrong offset!");

// Function Phoenix.PhxPerformanceProfilingActor.UpdatePerformanceProfiling
// 0x0060 (0x0060 - 0x0000)
struct PhxPerformanceProfilingActor_UpdatePerformanceProfiling final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FPerformanceProfilingData              ReturnValue;                                       // 0x0008(0x0058)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPerformanceProfilingActor_UpdatePerformanceProfiling) == 0x000008, "Wrong alignment on PhxPerformanceProfilingActor_UpdatePerformanceProfiling");
static_assert(sizeof(PhxPerformanceProfilingActor_UpdatePerformanceProfiling) == 0x000060, "Wrong size on PhxPerformanceProfilingActor_UpdatePerformanceProfiling");
static_assert(offsetof(PhxPerformanceProfilingActor_UpdatePerformanceProfiling, WorldContextObject) == 0x000000, "Member 'PhxPerformanceProfilingActor_UpdatePerformanceProfiling::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxPerformanceProfilingActor_UpdatePerformanceProfiling, ReturnValue) == 0x000008, "Member 'PhxPerformanceProfilingActor_UpdatePerformanceProfiling::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPerformanceProfilingActor.IsPerformanceProfilingPaused
// 0x0001 (0x0001 - 0x0000)
struct PhxPerformanceProfilingActor_IsPerformanceProfilingPaused final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPerformanceProfilingActor_IsPerformanceProfilingPaused) == 0x000001, "Wrong alignment on PhxPerformanceProfilingActor_IsPerformanceProfilingPaused");
static_assert(sizeof(PhxPerformanceProfilingActor_IsPerformanceProfilingPaused) == 0x000001, "Wrong size on PhxPerformanceProfilingActor_IsPerformanceProfilingPaused");
static_assert(offsetof(PhxPerformanceProfilingActor_IsPerformanceProfilingPaused, ReturnValue) == 0x000000, "Member 'PhxPerformanceProfilingActor_IsPerformanceProfilingPaused::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProjectile.BP_OnHit
// 0x0090 (0x0090 - 0x0000)
struct PhxProjectile_BP_OnHit final
{
public:
	class AActor*                                 OtherActor;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             HitResult;                                         // 0x0008(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProjectile_BP_OnHit) == 0x000008, "Wrong alignment on PhxProjectile_BP_OnHit");
static_assert(sizeof(PhxProjectile_BP_OnHit) == 0x000090, "Wrong size on PhxProjectile_BP_OnHit");
static_assert(offsetof(PhxProjectile_BP_OnHit, OtherActor) == 0x000000, "Member 'PhxProjectile_BP_OnHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxProjectile_BP_OnHit, HitResult) == 0x000008, "Member 'PhxProjectile_BP_OnHit::HitResult' has a wrong offset!");

// Function Phoenix.PhxProjectile.BP_OnHitCompanion
// 0x0008 (0x0008 - 0x0000)
struct PhxProjectile_BP_OnHitCompanion final
{
public:
	class APhxCharacter*                          CompanionCharacter;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProjectile_BP_OnHitCompanion) == 0x000008, "Wrong alignment on PhxProjectile_BP_OnHitCompanion");
static_assert(sizeof(PhxProjectile_BP_OnHitCompanion) == 0x000008, "Wrong size on PhxProjectile_BP_OnHitCompanion");
static_assert(offsetof(PhxProjectile_BP_OnHitCompanion, CompanionCharacter) == 0x000000, "Member 'PhxProjectile_BP_OnHitCompanion::CompanionCharacter' has a wrong offset!");

// Function Phoenix.PhxProjectile.BP_OnHitEnemy
// 0x0008 (0x0008 - 0x0000)
struct PhxProjectile_BP_OnHitEnemy final
{
public:
	class APhxCharacter*                          EnemyCharacter;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProjectile_BP_OnHitEnemy) == 0x000008, "Wrong alignment on PhxProjectile_BP_OnHitEnemy");
static_assert(sizeof(PhxProjectile_BP_OnHitEnemy) == 0x000008, "Wrong size on PhxProjectile_BP_OnHitEnemy");
static_assert(offsetof(PhxProjectile_BP_OnHitEnemy, EnemyCharacter) == 0x000000, "Member 'PhxProjectile_BP_OnHitEnemy::EnemyCharacter' has a wrong offset!");

// Function Phoenix.PhxProjectile.BP_OnHitPlayer
// 0x0008 (0x0008 - 0x0000)
struct PhxProjectile_BP_OnHitPlayer final
{
public:
	class APhxPlayerCharacter*                    PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProjectile_BP_OnHitPlayer) == 0x000008, "Wrong alignment on PhxProjectile_BP_OnHitPlayer");
static_assert(sizeof(PhxProjectile_BP_OnHitPlayer) == 0x000008, "Wrong size on PhxProjectile_BP_OnHitPlayer");
static_assert(offsetof(PhxProjectile_BP_OnHitPlayer, PlayerCharacter) == 0x000000, "Member 'PhxProjectile_BP_OnHitPlayer::PlayerCharacter' has a wrong offset!");

// Function Phoenix.PhxProjectile.HandleTakeAnyDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxProjectile_HandleTakeAnyDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProjectile_HandleTakeAnyDamage) == 0x000008, "Wrong alignment on PhxProjectile_HandleTakeAnyDamage");
static_assert(sizeof(PhxProjectile_HandleTakeAnyDamage) == 0x000028, "Wrong size on PhxProjectile_HandleTakeAnyDamage");
static_assert(offsetof(PhxProjectile_HandleTakeAnyDamage, DamagedActor) == 0x000000, "Member 'PhxProjectile_HandleTakeAnyDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxProjectile_HandleTakeAnyDamage, Damage) == 0x000008, "Member 'PhxProjectile_HandleTakeAnyDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxProjectile_HandleTakeAnyDamage, DamageType) == 0x000010, "Member 'PhxProjectile_HandleTakeAnyDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxProjectile_HandleTakeAnyDamage, InstigatedBy) == 0x000018, "Member 'PhxProjectile_HandleTakeAnyDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxProjectile_HandleTakeAnyDamage, DamageCauser) == 0x000020, "Member 'PhxProjectile_HandleTakeAnyDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxProjectile.OnProjectileBounce
// 0x0094 (0x0094 - 0x0000)
struct PhxProjectile_OnProjectileBounce final
{
public:
	struct FHitResult                             ImpactResult;                                      // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FVector                                ImpactVelocity;                                    // 0x0088(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProjectile_OnProjectileBounce) == 0x000004, "Wrong alignment on PhxProjectile_OnProjectileBounce");
static_assert(sizeof(PhxProjectile_OnProjectileBounce) == 0x000094, "Wrong size on PhxProjectile_OnProjectileBounce");
static_assert(offsetof(PhxProjectile_OnProjectileBounce, ImpactResult) == 0x000000, "Member 'PhxProjectile_OnProjectileBounce::ImpactResult' has a wrong offset!");
static_assert(offsetof(PhxProjectile_OnProjectileBounce, ImpactVelocity) == 0x000088, "Member 'PhxProjectile_OnProjectileBounce::ImpactVelocity' has a wrong offset!");

// Function Phoenix.PhxProjectile.OnProjectileStop
// 0x0088 (0x0088 - 0x0000)
struct PhxProjectile_OnProjectileStop final
{
public:
	struct FHitResult                             ImpactResult;                                      // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProjectile_OnProjectileStop) == 0x000004, "Wrong alignment on PhxProjectile_OnProjectileStop");
static_assert(sizeof(PhxProjectile_OnProjectileStop) == 0x000088, "Wrong size on PhxProjectile_OnProjectileStop");
static_assert(offsetof(PhxProjectile_OnProjectileStop, ImpactResult) == 0x000000, "Member 'PhxProjectile_OnProjectileStop::ImpactResult' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_TurnToFaceWorldPosition.CreateTurnToFaceWorldPositionTask
// 0x0020 (0x0020 - 0x0000)
struct PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask final
{
public:
	class UGameplayAbility*                       OwningAbility;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                WorldPosition;                                     // 0x0008(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Speed;                                             // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAbilityTask_TurnToFaceWorldPosition* ReturnValue;                                      // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask) == 0x000008, "Wrong alignment on PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask");
static_assert(sizeof(PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask) == 0x000020, "Wrong size on PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask");
static_assert(offsetof(PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask, OwningAbility) == 0x000000, "Member 'PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask::OwningAbility' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask, WorldPosition) == 0x000008, "Member 'PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask::WorldPosition' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask, Speed) == 0x000014, "Member 'PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask::Speed' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask, ReturnValue) == 0x000018, "Member 'PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_LoopingMontageWithTransitions.OnAngleConditionMet
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet final
{
public:
	float                                         TimeActive;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DeltaTime;                                         // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet) == 0x000004, "Wrong alignment on PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet");
static_assert(sizeof(PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet) == 0x000008, "Wrong size on PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet");
static_assert(offsetof(PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet, TimeActive) == 0x000000, "Member 'PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet::TimeActive' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet, DeltaTime) == 0x000004, "Member 'PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_LoopingMontageWithTransitions.ShouldTransitionLeft
// 0x0001 (0x0001 - 0x0000)
struct PhxAIGameplayAbility_LoopingMontageWithTransitions_ShouldTransitionLeft final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_LoopingMontageWithTransitions_ShouldTransitionLeft) == 0x000001, "Wrong alignment on PhxAIGameplayAbility_LoopingMontageWithTransitions_ShouldTransitionLeft");
static_assert(sizeof(PhxAIGameplayAbility_LoopingMontageWithTransitions_ShouldTransitionLeft) == 0x000001, "Wrong size on PhxAIGameplayAbility_LoopingMontageWithTransitions_ShouldTransitionLeft");
static_assert(offsetof(PhxAIGameplayAbility_LoopingMontageWithTransitions_ShouldTransitionLeft, ReturnValue) == 0x000000, "Member 'PhxAIGameplayAbility_LoopingMontageWithTransitions_ShouldTransitionLeft::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldMarkerWidget.SetDistance
// 0x0004 (0x0004 - 0x0000)
struct PhxWorldMarkerWidget_SetDistance final
{
public:
	float                                         Distance;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldMarkerWidget_SetDistance) == 0x000004, "Wrong alignment on PhxWorldMarkerWidget_SetDistance");
static_assert(sizeof(PhxWorldMarkerWidget_SetDistance) == 0x000004, "Wrong size on PhxWorldMarkerWidget_SetDistance");
static_assert(offsetof(PhxWorldMarkerWidget_SetDistance, Distance) == 0x000000, "Member 'PhxWorldMarkerWidget_SetDistance::Distance' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_WaitComponentHit.CreateWaitComponentTask
// 0x0028 (0x0028 - 0x0000)
struct PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask final
{
public:
	class UGameplayAbility*                       OwningAbility;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   TaskInstanceName;                                  // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    ComponentToCheck;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEndAfterFirstHit;                                 // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAbilityTask_WaitComponentHit*       ReturnValue;                                       // 0x0020(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask) == 0x000008, "Wrong alignment on PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask");
static_assert(sizeof(PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask) == 0x000028, "Wrong size on PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask, OwningAbility) == 0x000000, "Member 'PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask::OwningAbility' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask, TaskInstanceName) == 0x000008, "Member 'PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask::TaskInstanceName' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask, ComponentToCheck) == 0x000010, "Member 'PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask::ComponentToCheck' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask, bEndAfterFirstHit) == 0x000018, "Member 'PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask::bEndAfterFirstHit' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask, ReturnValue) == 0x000020, "Member 'PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_WaitComponentHit.OnHitCallback
// 0x00B0 (0x00B0 - 0x0000)
struct PhxAbilityTask_WaitComponentHit_OnHitCallback final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAbilityTask_WaitComponentHit_OnHitCallback) == 0x000008, "Wrong alignment on PhxAbilityTask_WaitComponentHit_OnHitCallback");
static_assert(sizeof(PhxAbilityTask_WaitComponentHit_OnHitCallback) == 0x0000B0, "Wrong size on PhxAbilityTask_WaitComponentHit_OnHitCallback");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_OnHitCallback, HitComp) == 0x000000, "Member 'PhxAbilityTask_WaitComponentHit_OnHitCallback::HitComp' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_OnHitCallback, OtherActor) == 0x000008, "Member 'PhxAbilityTask_WaitComponentHit_OnHitCallback::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_OnHitCallback, OtherComp) == 0x000010, "Member 'PhxAbilityTask_WaitComponentHit_OnHitCallback::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_OnHitCallback, NormalImpulse) == 0x000018, "Member 'PhxAbilityTask_WaitComponentHit_OnHitCallback::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitComponentHit_OnHitCallback, Hit) == 0x000024, "Member 'PhxAbilityTask_WaitComponentHit_OnHitCallback::Hit' has a wrong offset!");

// Function Phoenix.PhxAICharacterComponent_Parasite.HandleAIDied
// 0x0018 (0x0018 - 0x0000)
struct PhxAICharacterComponent_Parasite_HandleAIDied final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterComponent_Parasite_HandleAIDied) == 0x000008, "Wrong alignment on PhxAICharacterComponent_Parasite_HandleAIDied");
static_assert(sizeof(PhxAICharacterComponent_Parasite_HandleAIDied) == 0x000018, "Wrong size on PhxAICharacterComponent_Parasite_HandleAIDied");
static_assert(offsetof(PhxAICharacterComponent_Parasite_HandleAIDied, DeadCharacter) == 0x000000, "Member 'PhxAICharacterComponent_Parasite_HandleAIDied::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_Parasite_HandleAIDied, KillerActor) == 0x000008, "Member 'PhxAICharacterComponent_Parasite_HandleAIDied::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_Parasite_HandleAIDied, KillerController) == 0x000010, "Member 'PhxAICharacterComponent_Parasite_HandleAIDied::KillerController' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_WaitEarlyExitAllowed.ReceiveNotify
// 0x0008 (0x0008 - 0x0000)
struct PhxAbilityTask_WaitEarlyExitAllowed_ReceiveNotify final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_WaitEarlyExitAllowed_ReceiveNotify) == 0x000008, "Wrong alignment on PhxAbilityTask_WaitEarlyExitAllowed_ReceiveNotify");
static_assert(sizeof(PhxAbilityTask_WaitEarlyExitAllowed_ReceiveNotify) == 0x000008, "Wrong size on PhxAbilityTask_WaitEarlyExitAllowed_ReceiveNotify");
static_assert(offsetof(PhxAbilityTask_WaitEarlyExitAllowed_ReceiveNotify, Notify) == 0x000000, "Member 'PhxAbilityTask_WaitEarlyExitAllowed_ReceiveNotify::Notify' has a wrong offset!");

// Function Phoenix.PhxAICharacterComponent_Dangler.HandleAIDied
// 0x0018 (0x0018 - 0x0000)
struct PhxAICharacterComponent_Dangler_HandleAIDied final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterComponent_Dangler_HandleAIDied) == 0x000008, "Wrong alignment on PhxAICharacterComponent_Dangler_HandleAIDied");
static_assert(sizeof(PhxAICharacterComponent_Dangler_HandleAIDied) == 0x000018, "Wrong size on PhxAICharacterComponent_Dangler_HandleAIDied");
static_assert(offsetof(PhxAICharacterComponent_Dangler_HandleAIDied, DeadCharacter) == 0x000000, "Member 'PhxAICharacterComponent_Dangler_HandleAIDied::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_Dangler_HandleAIDied, KillerActor) == 0x000008, "Member 'PhxAICharacterComponent_Dangler_HandleAIDied::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_Dangler_HandleAIDied, KillerController) == 0x000010, "Member 'PhxAICharacterComponent_Dangler_HandleAIDied::KillerController' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_WaitForDeath.OnDeath
// 0x0020 (0x0020 - 0x0000)
struct PhxAbilityTask_WaitForDeath_OnDeath final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAbilityTask_WaitForDeath_OnDeath) == 0x000008, "Wrong alignment on PhxAbilityTask_WaitForDeath_OnDeath");
static_assert(sizeof(PhxAbilityTask_WaitForDeath_OnDeath) == 0x000020, "Wrong size on PhxAbilityTask_WaitForDeath_OnDeath");
static_assert(offsetof(PhxAbilityTask_WaitForDeath_OnDeath, DeadCharacter) == 0x000000, "Member 'PhxAbilityTask_WaitForDeath_OnDeath::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitForDeath_OnDeath, KillerActor) == 0x000008, "Member 'PhxAbilityTask_WaitForDeath_OnDeath::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitForDeath_OnDeath, KillerController) == 0x000010, "Member 'PhxAbilityTask_WaitForDeath_OnDeath::KillerController' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitForDeath_OnDeath, KillingBlowHealthDelta) == 0x000018, "Member 'PhxAbilityTask_WaitForDeath_OnDeath::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_WaitForPhxAnimNotify.ReceiveNotify
// 0x0008 (0x0008 - 0x0000)
struct PhxAbilityTask_WaitForPhxAnimNotify_ReceiveNotify final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_WaitForPhxAnimNotify_ReceiveNotify) == 0x000008, "Wrong alignment on PhxAbilityTask_WaitForPhxAnimNotify_ReceiveNotify");
static_assert(sizeof(PhxAbilityTask_WaitForPhxAnimNotify_ReceiveNotify) == 0x000008, "Wrong size on PhxAbilityTask_WaitForPhxAnimNotify_ReceiveNotify");
static_assert(offsetof(PhxAbilityTask_WaitForPhxAnimNotify_ReceiveNotify, Notify) == 0x000000, "Member 'PhxAbilityTask_WaitForPhxAnimNotify_ReceiveNotify::Notify' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_WaitForPhxAnimNotifyState.ReceiveNotifyStateBegin
// 0x0010 (0x0010 - 0x0000)
struct PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin final
{
public:
	const class UPhxAnimNotifyState*              NotifyState;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequenceBase*                      Animation;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin) == 0x000008, "Wrong alignment on PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin");
static_assert(sizeof(PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin) == 0x000010, "Wrong size on PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin");
static_assert(offsetof(PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin, NotifyState) == 0x000000, "Member 'PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin::NotifyState' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin, Animation) == 0x000008, "Member 'PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin::Animation' has a wrong offset!");

// Function Phoenix.PhxAbilityTask_WaitForPhxAnimNotifyState.ReceiveNotifyStateEnd
// 0x0010 (0x0010 - 0x0000)
struct PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd final
{
public:
	const class UPhxAnimNotifyState*              NotifyState;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequenceBase*                      Animation;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd) == 0x000008, "Wrong alignment on PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd");
static_assert(sizeof(PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd) == 0x000010, "Wrong size on PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd");
static_assert(offsetof(PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd, NotifyState) == 0x000000, "Member 'PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd::NotifyState' has a wrong offset!");
static_assert(offsetof(PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd, Animation) == 0x000008, "Member 'PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd::Animation' has a wrong offset!");

// Function Phoenix.PhxAICharacterComponent_Leon_Infected.ConsumeAlphaCall
// 0x0001 (0x0001 - 0x0000)
struct PhxAICharacterComponent_Leon_Infected_ConsumeAlphaCall final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterComponent_Leon_Infected_ConsumeAlphaCall) == 0x000001, "Wrong alignment on PhxAICharacterComponent_Leon_Infected_ConsumeAlphaCall");
static_assert(sizeof(PhxAICharacterComponent_Leon_Infected_ConsumeAlphaCall) == 0x000001, "Wrong size on PhxAICharacterComponent_Leon_Infected_ConsumeAlphaCall");
static_assert(offsetof(PhxAICharacterComponent_Leon_Infected_ConsumeAlphaCall, ReturnValue) == 0x000000, "Member 'PhxAICharacterComponent_Leon_Infected_ConsumeAlphaCall::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacterComponent_Leon_Infected.OnBodyPartDied
// 0x0020 (0x0020 - 0x0000)
struct PhxAICharacterComponent_Leon_Infected_OnBodyPartDied final
{
public:
	TArray<EPhxBodyPartType>                      DestroyedBodyParts;                                // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
	class AActor*                                 InstigatorActor;                                   // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OwnerCharacter;                                    // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterComponent_Leon_Infected_OnBodyPartDied) == 0x000008, "Wrong alignment on PhxAICharacterComponent_Leon_Infected_OnBodyPartDied");
static_assert(sizeof(PhxAICharacterComponent_Leon_Infected_OnBodyPartDied) == 0x000020, "Wrong size on PhxAICharacterComponent_Leon_Infected_OnBodyPartDied");
static_assert(offsetof(PhxAICharacterComponent_Leon_Infected_OnBodyPartDied, DestroyedBodyParts) == 0x000000, "Member 'PhxAICharacterComponent_Leon_Infected_OnBodyPartDied::DestroyedBodyParts' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_Leon_Infected_OnBodyPartDied, InstigatorActor) == 0x000010, "Member 'PhxAICharacterComponent_Leon_Infected_OnBodyPartDied::InstigatorActor' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_Leon_Infected_OnBodyPartDied, OwnerCharacter) == 0x000018, "Member 'PhxAICharacterComponent_Leon_Infected_OnBodyPartDied::OwnerCharacter' has a wrong offset!");

// Function Phoenix.PhxAICharacterDefinition.GetValidBlueprintVariationIndices
// 0x0038 (0x0038 - 0x0000)
struct PhxAICharacterDefinition_GetValidBlueprintVariationIndices final
{
public:
	TSoftObjectPtr<class UPhxAICharacterVariantDefinition> AttributeVariationDefinition;             // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<int32>                                 ReturnValue;                                       // 0x0028(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterDefinition_GetValidBlueprintVariationIndices) == 0x000008, "Wrong alignment on PhxAICharacterDefinition_GetValidBlueprintVariationIndices");
static_assert(sizeof(PhxAICharacterDefinition_GetValidBlueprintVariationIndices) == 0x000038, "Wrong size on PhxAICharacterDefinition_GetValidBlueprintVariationIndices");
static_assert(offsetof(PhxAICharacterDefinition_GetValidBlueprintVariationIndices, AttributeVariationDefinition) == 0x000000, "Member 'PhxAICharacterDefinition_GetValidBlueprintVariationIndices::AttributeVariationDefinition' has a wrong offset!");
static_assert(offsetof(PhxAICharacterDefinition_GetValidBlueprintVariationIndices, ReturnValue) == 0x000028, "Member 'PhxAICharacterDefinition_GetValidBlueprintVariationIndices::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWeaponSwitcher.ConfirmHeld
// 0x0004 (0x0004 - 0x0000)
struct PhxWeaponSwitcher_ConfirmHeld final
{
public:
	float                                         TimeHeld;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponSwitcher_ConfirmHeld) == 0x000004, "Wrong alignment on PhxWeaponSwitcher_ConfirmHeld");
static_assert(sizeof(PhxWeaponSwitcher_ConfirmHeld) == 0x000004, "Wrong size on PhxWeaponSwitcher_ConfirmHeld");
static_assert(offsetof(PhxWeaponSwitcher_ConfirmHeld, TimeHeld) == 0x000000, "Member 'PhxWeaponSwitcher_ConfirmHeld::TimeHeld' has a wrong offset!");

// Function Phoenix.PhxWeaponSwitcher.HandleDirectionInput
// 0x0001 (0x0001 - 0x0000)
struct PhxWeaponSwitcher_HandleDirectionInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponSwitcher_HandleDirectionInput) == 0x000001, "Wrong alignment on PhxWeaponSwitcher_HandleDirectionInput");
static_assert(sizeof(PhxWeaponSwitcher_HandleDirectionInput) == 0x000001, "Wrong size on PhxWeaponSwitcher_HandleDirectionInput");
static_assert(offsetof(PhxWeaponSwitcher_HandleDirectionInput, Direction) == 0x000000, "Member 'PhxWeaponSwitcher_HandleDirectionInput::Direction' has a wrong offset!");

// Function Phoenix.PhxWeaponSwitcher.SetCurrentSelected
// 0x0008 (0x0008 - 0x0000)
struct PhxWeaponSwitcher_SetCurrentSelected final
{
public:
	class UPhxWeaponSwitcherSlot*                 WeaponSlot;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponSwitcher_SetCurrentSelected) == 0x000008, "Wrong alignment on PhxWeaponSwitcher_SetCurrentSelected");
static_assert(sizeof(PhxWeaponSwitcher_SetCurrentSelected) == 0x000008, "Wrong size on PhxWeaponSwitcher_SetCurrentSelected");
static_assert(offsetof(PhxWeaponSwitcher_SetCurrentSelected, WeaponSlot) == 0x000000, "Member 'PhxWeaponSwitcher_SetCurrentSelected::WeaponSlot' has a wrong offset!");

// Function Phoenix.PhxWeaponSwitcher.GetCurrentSelected
// 0x0008 (0x0008 - 0x0000)
struct PhxWeaponSwitcher_GetCurrentSelected final
{
public:
	class UPhxWeaponSwitcherSlot*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponSwitcher_GetCurrentSelected) == 0x000008, "Wrong alignment on PhxWeaponSwitcher_GetCurrentSelected");
static_assert(sizeof(PhxWeaponSwitcher_GetCurrentSelected) == 0x000008, "Wrong size on PhxWeaponSwitcher_GetCurrentSelected");
static_assert(offsetof(PhxWeaponSwitcher_GetCurrentSelected, ReturnValue) == 0x000000, "Member 'PhxWeaponSwitcher_GetCurrentSelected::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWeaponSwitcher.IsConfirmPressAllowed
// 0x0001 (0x0001 - 0x0000)
struct PhxWeaponSwitcher_IsConfirmPressAllowed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponSwitcher_IsConfirmPressAllowed) == 0x000001, "Wrong alignment on PhxWeaponSwitcher_IsConfirmPressAllowed");
static_assert(sizeof(PhxWeaponSwitcher_IsConfirmPressAllowed) == 0x000001, "Wrong size on PhxWeaponSwitcher_IsConfirmPressAllowed");
static_assert(offsetof(PhxWeaponSwitcher_IsConfirmPressAllowed, ReturnValue) == 0x000000, "Member 'PhxWeaponSwitcher_IsConfirmPressAllowed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxSaveGameManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxSaveGameManager*                    ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_Get) == 0x000008, "Wrong alignment on PhxSaveGameManager_Get");
static_assert(sizeof(PhxSaveGameManager_Get) == 0x000010, "Wrong size on PhxSaveGameManager_Get");
static_assert(offsetof(PhxSaveGameManager_Get, WorldContextObject) == 0x000000, "Member 'PhxSaveGameManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_Get, ReturnValue) == 0x000008, "Member 'PhxSaveGameManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.AttemptAutoSave
// 0x0008 (0x0008 - 0x0000)
struct PhxSaveGameManager_AttemptAutoSave final
{
public:
	const class UPhxDifficultySettings*           DifficultySettings;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_AttemptAutoSave) == 0x000008, "Wrong alignment on PhxSaveGameManager_AttemptAutoSave");
static_assert(sizeof(PhxSaveGameManager_AttemptAutoSave) == 0x000008, "Wrong size on PhxSaveGameManager_AttemptAutoSave");
static_assert(offsetof(PhxSaveGameManager_AttemptAutoSave, DifficultySettings) == 0x000000, "Member 'PhxSaveGameManager_AttemptAutoSave::DifficultySettings' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.BackupSaveFile
// 0x0050 (0x0050 - 0x0000)
struct PhxSaveGameManager_BackupSaveFile final
{
public:
	struct FPhxSaveGameInfo                       SaveFileInfo;                                      // 0x0000(0x0048)(Parm, NativeAccessSpecifierPublic)
	ESDSUserCloudType                             CloudSaveTarget;                                   // 0x0048(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_BackupSaveFile) == 0x000008, "Wrong alignment on PhxSaveGameManager_BackupSaveFile");
static_assert(sizeof(PhxSaveGameManager_BackupSaveFile) == 0x000050, "Wrong size on PhxSaveGameManager_BackupSaveFile");
static_assert(offsetof(PhxSaveGameManager_BackupSaveFile, SaveFileInfo) == 0x000000, "Member 'PhxSaveGameManager_BackupSaveFile::SaveFileInfo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_BackupSaveFile, CloudSaveTarget) == 0x000048, "Member 'PhxSaveGameManager_BackupSaveFile::CloudSaveTarget' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.CanCreateNewSaveFile
// 0x0001 (0x0001 - 0x0000)
struct PhxSaveGameManager_CanCreateNewSaveFile final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_CanCreateNewSaveFile) == 0x000001, "Wrong alignment on PhxSaveGameManager_CanCreateNewSaveFile");
static_assert(sizeof(PhxSaveGameManager_CanCreateNewSaveFile) == 0x000001, "Wrong size on PhxSaveGameManager_CanCreateNewSaveFile");
static_assert(offsetof(PhxSaveGameManager_CanCreateNewSaveFile, ReturnValue) == 0x000000, "Member 'PhxSaveGameManager_CanCreateNewSaveFile::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.DebugLoadCheckpoint
// 0x0028 (0x0028 - 0x0000)
struct PhxSaveGameManager_DebugLoadCheckpoint final
{
public:
	class UWorld*                                 WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 LevelName;                                         // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 CheckpointId;                                      // 0x0018(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_DebugLoadCheckpoint) == 0x000008, "Wrong alignment on PhxSaveGameManager_DebugLoadCheckpoint");
static_assert(sizeof(PhxSaveGameManager_DebugLoadCheckpoint) == 0x000028, "Wrong size on PhxSaveGameManager_DebugLoadCheckpoint");
static_assert(offsetof(PhxSaveGameManager_DebugLoadCheckpoint, WorldContext) == 0x000000, "Member 'PhxSaveGameManager_DebugLoadCheckpoint::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_DebugLoadCheckpoint, LevelName) == 0x000008, "Member 'PhxSaveGameManager_DebugLoadCheckpoint::LevelName' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_DebugLoadCheckpoint, CheckpointId) == 0x000018, "Member 'PhxSaveGameManager_DebugLoadCheckpoint::CheckpointId' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.DebugSaveCheckpoint
// 0x0020 (0x0020 - 0x0000)
struct PhxSaveGameManager_DebugSaveCheckpoint final
{
public:
	class FString                                 LevelName;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 CheckpointId;                                      // 0x0010(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_DebugSaveCheckpoint) == 0x000008, "Wrong alignment on PhxSaveGameManager_DebugSaveCheckpoint");
static_assert(sizeof(PhxSaveGameManager_DebugSaveCheckpoint) == 0x000020, "Wrong size on PhxSaveGameManager_DebugSaveCheckpoint");
static_assert(offsetof(PhxSaveGameManager_DebugSaveCheckpoint, LevelName) == 0x000000, "Member 'PhxSaveGameManager_DebugSaveCheckpoint::LevelName' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_DebugSaveCheckpoint, CheckpointId) == 0x000010, "Member 'PhxSaveGameManager_DebugSaveCheckpoint::CheckpointId' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.DeleteSaveFile
// 0x0048 (0x0048 - 0x0000)
struct PhxSaveGameManager_DeleteSaveFile final
{
public:
	struct FPhxSaveGameInfo                       SaveToDelete;                                      // 0x0000(0x0048)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_DeleteSaveFile) == 0x000008, "Wrong alignment on PhxSaveGameManager_DeleteSaveFile");
static_assert(sizeof(PhxSaveGameManager_DeleteSaveFile) == 0x000048, "Wrong size on PhxSaveGameManager_DeleteSaveFile");
static_assert(offsetof(PhxSaveGameManager_DeleteSaveFile, SaveToDelete) == 0x000000, "Member 'PhxSaveGameManager_DeleteSaveFile::SaveToDelete' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.LoadGame
// 0x0020 (0x0020 - 0x0000)
struct PhxSaveGameManager_LoadGame final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 SaveSlot;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         UserIndex;                                         // 0x0018(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLoadForNewGamePlus;                               // 0x001C(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTransfer;                                         // 0x001D(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1E[0x2];                                       // 0x001E(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_LoadGame) == 0x000008, "Wrong alignment on PhxSaveGameManager_LoadGame");
static_assert(sizeof(PhxSaveGameManager_LoadGame) == 0x000020, "Wrong size on PhxSaveGameManager_LoadGame");
static_assert(offsetof(PhxSaveGameManager_LoadGame, WorldContext) == 0x000000, "Member 'PhxSaveGameManager_LoadGame::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadGame, SaveSlot) == 0x000008, "Member 'PhxSaveGameManager_LoadGame::SaveSlot' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadGame, UserIndex) == 0x000018, "Member 'PhxSaveGameManager_LoadGame::UserIndex' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadGame, bLoadForNewGamePlus) == 0x00001C, "Member 'PhxSaveGameManager_LoadGame::bLoadForNewGamePlus' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadGame, bTransfer) == 0x00001D, "Member 'PhxSaveGameManager_LoadGame::bTransfer' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.LoadGameIntoLevel
// 0x00A0 (0x00A0 - 0x0000)
struct PhxSaveGameManager_LoadGameIntoLevel final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FPhxSaveGameInfo                       SaveFile;                                          // 0x0008(0x0048)(Parm, NativeAccessSpecifierPublic)
	struct FGameplayTagContainer                  NewGameTypeTag;                                    // 0x0050(0x0020)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class ULevelTransitionDataAsset> LevelToTransitionTo;                             // 0x0070(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         UserIndex;                                         // 0x0098(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTransfer;                                         // 0x009C(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9D[0x3];                                       // 0x009D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_LoadGameIntoLevel) == 0x000008, "Wrong alignment on PhxSaveGameManager_LoadGameIntoLevel");
static_assert(sizeof(PhxSaveGameManager_LoadGameIntoLevel) == 0x0000A0, "Wrong size on PhxSaveGameManager_LoadGameIntoLevel");
static_assert(offsetof(PhxSaveGameManager_LoadGameIntoLevel, WorldContext) == 0x000000, "Member 'PhxSaveGameManager_LoadGameIntoLevel::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadGameIntoLevel, SaveFile) == 0x000008, "Member 'PhxSaveGameManager_LoadGameIntoLevel::SaveFile' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadGameIntoLevel, NewGameTypeTag) == 0x000050, "Member 'PhxSaveGameManager_LoadGameIntoLevel::NewGameTypeTag' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadGameIntoLevel, LevelToTransitionTo) == 0x000070, "Member 'PhxSaveGameManager_LoadGameIntoLevel::LevelToTransitionTo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadGameIntoLevel, UserIndex) == 0x000098, "Member 'PhxSaveGameManager_LoadGameIntoLevel::UserIndex' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadGameIntoLevel, bTransfer) == 0x00009C, "Member 'PhxSaveGameManager_LoadGameIntoLevel::bTransfer' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.LoadSaveFile
// 0x0058 (0x0058 - 0x0000)
struct PhxSaveGameManager_LoadSaveFile final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FPhxSaveGameInfo                       SaveFile;                                          // 0x0008(0x0048)(Parm, NativeAccessSpecifierPublic)
	bool                                          bLoadForNewGamePlus;                               // 0x0050(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_51[0x7];                                       // 0x0051(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_LoadSaveFile) == 0x000008, "Wrong alignment on PhxSaveGameManager_LoadSaveFile");
static_assert(sizeof(PhxSaveGameManager_LoadSaveFile) == 0x000058, "Wrong size on PhxSaveGameManager_LoadSaveFile");
static_assert(offsetof(PhxSaveGameManager_LoadSaveFile, WorldContext) == 0x000000, "Member 'PhxSaveGameManager_LoadSaveFile::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadSaveFile, SaveFile) == 0x000008, "Member 'PhxSaveGameManager_LoadSaveFile::SaveFile' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_LoadSaveFile, bLoadForNewGamePlus) == 0x000050, "Member 'PhxSaveGameManager_LoadSaveFile::bLoadForNewGamePlus' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.OverwriteSaveFile
// 0x0048 (0x0048 - 0x0000)
struct PhxSaveGameManager_OverwriteSaveFile final
{
public:
	struct FPhxSaveGameInfo                       SaveToOverwrite;                                   // 0x0000(0x0048)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_OverwriteSaveFile) == 0x000008, "Wrong alignment on PhxSaveGameManager_OverwriteSaveFile");
static_assert(sizeof(PhxSaveGameManager_OverwriteSaveFile) == 0x000048, "Wrong size on PhxSaveGameManager_OverwriteSaveFile");
static_assert(offsetof(PhxSaveGameManager_OverwriteSaveFile, SaveToOverwrite) == 0x000000, "Member 'PhxSaveGameManager_OverwriteSaveFile::SaveToOverwrite' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.RefreshSaveInfoList
// 0x0001 (0x0001 - 0x0000)
struct PhxSaveGameManager_RefreshSaveInfoList final
{
public:
	bool                                          bRefreshCloudSaves;                                // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_RefreshSaveInfoList) == 0x000001, "Wrong alignment on PhxSaveGameManager_RefreshSaveInfoList");
static_assert(sizeof(PhxSaveGameManager_RefreshSaveInfoList) == 0x000001, "Wrong size on PhxSaveGameManager_RefreshSaveInfoList");
static_assert(offsetof(PhxSaveGameManager_RefreshSaveInfoList, bRefreshCloudSaves) == 0x000000, "Member 'PhxSaveGameManager_RefreshSaveInfoList::bRefreshCloudSaves' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.SaveGame
// 0x0018 (0x0018 - 0x0000)
struct PhxSaveGameManager_SaveGame final
{
public:
	class FString                                 SaveSlot;                                          // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         UserIndex;                                         // 0x0010(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForceSave;                                        // 0x0014(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15[0x3];                                       // 0x0015(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_SaveGame) == 0x000008, "Wrong alignment on PhxSaveGameManager_SaveGame");
static_assert(sizeof(PhxSaveGameManager_SaveGame) == 0x000018, "Wrong size on PhxSaveGameManager_SaveGame");
static_assert(offsetof(PhxSaveGameManager_SaveGame, SaveSlot) == 0x000000, "Member 'PhxSaveGameManager_SaveGame::SaveSlot' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_SaveGame, UserIndex) == 0x000010, "Member 'PhxSaveGameManager_SaveGame::UserIndex' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_SaveGame, bForceSave) == 0x000014, "Member 'PhxSaveGameManager_SaveGame::bForceSave' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.SubmitSaveGame
// 0x0018 (0x0018 - 0x0000)
struct PhxSaveGameManager_SubmitSaveGame final
{
public:
	class FString                                 SaveSlot;                                          // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         UserIndex;                                         // 0x0010(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxSaveGameType                              SaveType;                                          // 0x0014(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bOverwritingExistingSave;                          // 0x0015(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForceSave;                                        // 0x0016(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_17[0x1];                                       // 0x0017(0x0001)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_SubmitSaveGame) == 0x000008, "Wrong alignment on PhxSaveGameManager_SubmitSaveGame");
static_assert(sizeof(PhxSaveGameManager_SubmitSaveGame) == 0x000018, "Wrong size on PhxSaveGameManager_SubmitSaveGame");
static_assert(offsetof(PhxSaveGameManager_SubmitSaveGame, SaveSlot) == 0x000000, "Member 'PhxSaveGameManager_SubmitSaveGame::SaveSlot' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_SubmitSaveGame, UserIndex) == 0x000010, "Member 'PhxSaveGameManager_SubmitSaveGame::UserIndex' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_SubmitSaveGame, SaveType) == 0x000014, "Member 'PhxSaveGameManager_SubmitSaveGame::SaveType' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_SubmitSaveGame, bOverwritingExistingSave) == 0x000015, "Member 'PhxSaveGameManager_SubmitSaveGame::bOverwritingExistingSave' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_SubmitSaveGame, bForceSave) == 0x000016, "Member 'PhxSaveGameManager_SubmitSaveGame::bForceSave' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.CanSaveGame
// 0x0001 (0x0001 - 0x0000)
struct PhxSaveGameManager_CanSaveGame final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_CanSaveGame) == 0x000001, "Wrong alignment on PhxSaveGameManager_CanSaveGame");
static_assert(sizeof(PhxSaveGameManager_CanSaveGame) == 0x000001, "Wrong size on PhxSaveGameManager_CanSaveGame");
static_assert(offsetof(PhxSaveGameManager_CanSaveGame, ReturnValue) == 0x000000, "Member 'PhxSaveGameManager_CanSaveGame::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.CanWriteDebugSaveData
// 0x0028 (0x0028 - 0x0000)
struct PhxSaveGameManager_CanWriteDebugSaveData final
{
public:
	class FString                                 LevelName;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 CheckpointId;                                      // 0x0010(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0020(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x7];                                       // 0x0021(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_CanWriteDebugSaveData) == 0x000008, "Wrong alignment on PhxSaveGameManager_CanWriteDebugSaveData");
static_assert(sizeof(PhxSaveGameManager_CanWriteDebugSaveData) == 0x000028, "Wrong size on PhxSaveGameManager_CanWriteDebugSaveData");
static_assert(offsetof(PhxSaveGameManager_CanWriteDebugSaveData, LevelName) == 0x000000, "Member 'PhxSaveGameManager_CanWriteDebugSaveData::LevelName' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_CanWriteDebugSaveData, CheckpointId) == 0x000010, "Member 'PhxSaveGameManager_CanWriteDebugSaveData::CheckpointId' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_CanWriteDebugSaveData, ReturnValue) == 0x000020, "Member 'PhxSaveGameManager_CanWriteDebugSaveData::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.DoesDebugSaveCheckpointExist
// 0x0028 (0x0028 - 0x0000)
struct PhxSaveGameManager_DoesDebugSaveCheckpointExist final
{
public:
	class FString                                 LevelName;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 CheckpointId;                                      // 0x0010(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0020(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x7];                                       // 0x0021(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_DoesDebugSaveCheckpointExist) == 0x000008, "Wrong alignment on PhxSaveGameManager_DoesDebugSaveCheckpointExist");
static_assert(sizeof(PhxSaveGameManager_DoesDebugSaveCheckpointExist) == 0x000028, "Wrong size on PhxSaveGameManager_DoesDebugSaveCheckpointExist");
static_assert(offsetof(PhxSaveGameManager_DoesDebugSaveCheckpointExist, LevelName) == 0x000000, "Member 'PhxSaveGameManager_DoesDebugSaveCheckpointExist::LevelName' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_DoesDebugSaveCheckpointExist, CheckpointId) == 0x000010, "Member 'PhxSaveGameManager_DoesDebugSaveCheckpointExist::CheckpointId' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_DoesDebugSaveCheckpointExist, ReturnValue) == 0x000020, "Member 'PhxSaveGameManager_DoesDebugSaveCheckpointExist::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetCachedSaveInfo
// 0x0010 (0x0010 - 0x0000)
struct PhxSaveGameManager_GetCachedSaveInfo final
{
public:
	TArray<struct FPhxSaveGameInfo>               ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_GetCachedSaveInfo) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetCachedSaveInfo");
static_assert(sizeof(PhxSaveGameManager_GetCachedSaveInfo) == 0x000010, "Wrong size on PhxSaveGameManager_GetCachedSaveInfo");
static_assert(offsetof(PhxSaveGameManager_GetCachedSaveInfo, ReturnValue) == 0x000000, "Member 'PhxSaveGameManager_GetCachedSaveInfo::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetCheckpointText
// 0x0060 (0x0060 - 0x0000)
struct PhxSaveGameManager_GetCheckpointText final
{
public:
	struct FPhxSaveGameInfo                       SaveInfo;                                          // 0x0000(0x0048)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class FText                                   ReturnValue;                                       // 0x0048(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_GetCheckpointText) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetCheckpointText");
static_assert(sizeof(PhxSaveGameManager_GetCheckpointText) == 0x000060, "Wrong size on PhxSaveGameManager_GetCheckpointText");
static_assert(offsetof(PhxSaveGameManager_GetCheckpointText, SaveInfo) == 0x000000, "Member 'PhxSaveGameManager_GetCheckpointText::SaveInfo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetCheckpointText, ReturnValue) == 0x000048, "Member 'PhxSaveGameManager_GetCheckpointText::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetDebugSaveTimeStamp
// 0x0030 (0x0030 - 0x0000)
struct PhxSaveGameManager_GetDebugSaveTimeStamp final
{
public:
	class FString                                 LevelName;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 CheckpointId;                                      // 0x0010(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ReturnValue;                                       // 0x0020(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_GetDebugSaveTimeStamp) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetDebugSaveTimeStamp");
static_assert(sizeof(PhxSaveGameManager_GetDebugSaveTimeStamp) == 0x000030, "Wrong size on PhxSaveGameManager_GetDebugSaveTimeStamp");
static_assert(offsetof(PhxSaveGameManager_GetDebugSaveTimeStamp, LevelName) == 0x000000, "Member 'PhxSaveGameManager_GetDebugSaveTimeStamp::LevelName' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetDebugSaveTimeStamp, CheckpointId) == 0x000010, "Member 'PhxSaveGameManager_GetDebugSaveTimeStamp::CheckpointId' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetDebugSaveTimeStamp, ReturnValue) == 0x000020, "Member 'PhxSaveGameManager_GetDebugSaveTimeStamp::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetDifficultyTag
// 0x0050 (0x0050 - 0x0000)
struct PhxSaveGameManager_GetDifficultyTag final
{
public:
	struct FPhxSaveGameInfo                       SaveInfo;                                          // 0x0000(0x0048)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ReturnValue;                                       // 0x0048(0x0008)(Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_GetDifficultyTag) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetDifficultyTag");
static_assert(sizeof(PhxSaveGameManager_GetDifficultyTag) == 0x000050, "Wrong size on PhxSaveGameManager_GetDifficultyTag");
static_assert(offsetof(PhxSaveGameManager_GetDifficultyTag, SaveInfo) == 0x000000, "Member 'PhxSaveGameManager_GetDifficultyTag::SaveInfo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetDifficultyTag, ReturnValue) == 0x000048, "Member 'PhxSaveGameManager_GetDifficultyTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetDifficultyText
// 0x0060 (0x0060 - 0x0000)
struct PhxSaveGameManager_GetDifficultyText final
{
public:
	struct FPhxSaveGameInfo                       SaveInfo;                                          // 0x0000(0x0048)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class FText                                   ReturnValue;                                       // 0x0048(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_GetDifficultyText) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetDifficultyText");
static_assert(sizeof(PhxSaveGameManager_GetDifficultyText) == 0x000060, "Wrong size on PhxSaveGameManager_GetDifficultyText");
static_assert(offsetof(PhxSaveGameManager_GetDifficultyText, SaveInfo) == 0x000000, "Member 'PhxSaveGameManager_GetDifficultyText::SaveInfo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetDifficultyText, ReturnValue) == 0x000048, "Member 'PhxSaveGameManager_GetDifficultyText::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetIsGameMainStoryComplete
// 0x0050 (0x0050 - 0x0000)
struct PhxSaveGameManager_GetIsGameMainStoryComplete final
{
public:
	struct FPhxSaveGameInfo                       SaveInfo;                                          // 0x0000(0x0048)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0048(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_GetIsGameMainStoryComplete) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetIsGameMainStoryComplete");
static_assert(sizeof(PhxSaveGameManager_GetIsGameMainStoryComplete) == 0x000050, "Wrong size on PhxSaveGameManager_GetIsGameMainStoryComplete");
static_assert(offsetof(PhxSaveGameManager_GetIsGameMainStoryComplete, SaveInfo) == 0x000000, "Member 'PhxSaveGameManager_GetIsGameMainStoryComplete::SaveInfo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetIsGameMainStoryComplete, ReturnValue) == 0x000048, "Member 'PhxSaveGameManager_GetIsGameMainStoryComplete::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetIsGameNGPlus
// 0x0050 (0x0050 - 0x0000)
struct PhxSaveGameManager_GetIsGameNGPlus final
{
public:
	struct FPhxSaveGameInfo                       SaveInfo;                                          // 0x0000(0x0048)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0048(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_GetIsGameNGPlus) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetIsGameNGPlus");
static_assert(sizeof(PhxSaveGameManager_GetIsGameNGPlus) == 0x000050, "Wrong size on PhxSaveGameManager_GetIsGameNGPlus");
static_assert(offsetof(PhxSaveGameManager_GetIsGameNGPlus, SaveInfo) == 0x000000, "Member 'PhxSaveGameManager_GetIsGameNGPlus::SaveInfo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetIsGameNGPlus, ReturnValue) == 0x000048, "Member 'PhxSaveGameManager_GetIsGameNGPlus::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetIsGameStoryDLC
// 0x0050 (0x0050 - 0x0000)
struct PhxSaveGameManager_GetIsGameStoryDLC final
{
public:
	struct FPhxSaveGameInfo                       SaveInfo;                                          // 0x0000(0x0048)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0048(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSaveGameManager_GetIsGameStoryDLC) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetIsGameStoryDLC");
static_assert(sizeof(PhxSaveGameManager_GetIsGameStoryDLC) == 0x000050, "Wrong size on PhxSaveGameManager_GetIsGameStoryDLC");
static_assert(offsetof(PhxSaveGameManager_GetIsGameStoryDLC, SaveInfo) == 0x000000, "Member 'PhxSaveGameManager_GetIsGameStoryDLC::SaveInfo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetIsGameStoryDLC, ReturnValue) == 0x000048, "Member 'PhxSaveGameManager_GetIsGameStoryDLC::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetLastSaveSlot
// 0x0010 (0x0010 - 0x0000)
struct PhxSaveGameManager_GetLastSaveSlot final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_GetLastSaveSlot) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetLastSaveSlot");
static_assert(sizeof(PhxSaveGameManager_GetLastSaveSlot) == 0x000010, "Wrong size on PhxSaveGameManager_GetLastSaveSlot");
static_assert(offsetof(PhxSaveGameManager_GetLastSaveSlot, ReturnValue) == 0x000000, "Member 'PhxSaveGameManager_GetLastSaveSlot::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetLevelNameText
// 0x0060 (0x0060 - 0x0000)
struct PhxSaveGameManager_GetLevelNameText final
{
public:
	struct FPhxSaveGameInfo                       SaveInfo;                                          // 0x0000(0x0048)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class FText                                   ReturnValue;                                       // 0x0048(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_GetLevelNameText) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetLevelNameText");
static_assert(sizeof(PhxSaveGameManager_GetLevelNameText) == 0x000060, "Wrong size on PhxSaveGameManager_GetLevelNameText");
static_assert(offsetof(PhxSaveGameManager_GetLevelNameText, SaveInfo) == 0x000000, "Member 'PhxSaveGameManager_GetLevelNameText::SaveInfo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetLevelNameText, ReturnValue) == 0x000048, "Member 'PhxSaveGameManager_GetLevelNameText::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetNewSaveInfo
// 0x0048 (0x0048 - 0x0000)
struct PhxSaveGameManager_GetNewSaveInfo final
{
public:
	struct FPhxSaveGameInfo                       ReturnValue;                                       // 0x0000(0x0048)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_GetNewSaveInfo) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetNewSaveInfo");
static_assert(sizeof(PhxSaveGameManager_GetNewSaveInfo) == 0x000048, "Wrong size on PhxSaveGameManager_GetNewSaveInfo");
static_assert(offsetof(PhxSaveGameManager_GetNewSaveInfo, ReturnValue) == 0x000000, "Member 'PhxSaveGameManager_GetNewSaveInfo::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSaveGameManager.GetObjectiveText
// 0x0060 (0x0060 - 0x0000)
struct PhxSaveGameManager_GetObjectiveText final
{
public:
	struct FPhxSaveGameInfo                       SaveInfo;                                          // 0x0000(0x0048)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class FText                                   ReturnValue;                                       // 0x0048(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSaveGameManager_GetObjectiveText) == 0x000008, "Wrong alignment on PhxSaveGameManager_GetObjectiveText");
static_assert(sizeof(PhxSaveGameManager_GetObjectiveText) == 0x000060, "Wrong size on PhxSaveGameManager_GetObjectiveText");
static_assert(offsetof(PhxSaveGameManager_GetObjectiveText, SaveInfo) == 0x000000, "Member 'PhxSaveGameManager_GetObjectiveText::SaveInfo' has a wrong offset!");
static_assert(offsetof(PhxSaveGameManager_GetObjectiveText, ReturnValue) == 0x000048, "Member 'PhxSaveGameManager_GetObjectiveText::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootProp_Item.GetItemCost
// 0x0004 (0x0004 - 0x0000)
struct PhxRiotModeLootProp_Item_GetItemCost final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootProp_Item_GetItemCost) == 0x000004, "Wrong alignment on PhxRiotModeLootProp_Item_GetItemCost");
static_assert(sizeof(PhxRiotModeLootProp_Item_GetItemCost) == 0x000004, "Wrong size on PhxRiotModeLootProp_Item_GetItemCost");
static_assert(offsetof(PhxRiotModeLootProp_Item_GetItemCost, ReturnValue) == 0x000000, "Member 'PhxRiotModeLootProp_Item_GetItemCost::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootProp_Item.SetItemCost
// 0x0004 (0x0004 - 0x0000)
struct PhxRiotModeLootProp_Item_SetItemCost final
{
public:
	int32                                         Cost;                                              // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootProp_Item_SetItemCost) == 0x000004, "Wrong alignment on PhxRiotModeLootProp_Item_SetItemCost");
static_assert(sizeof(PhxRiotModeLootProp_Item_SetItemCost) == 0x000004, "Wrong size on PhxRiotModeLootProp_Item_SetItemCost");
static_assert(offsetof(PhxRiotModeLootProp_Item_SetItemCost, Cost) == 0x000000, "Member 'PhxRiotModeLootProp_Item_SetItemCost::Cost' has a wrong offset!");

// Function Phoenix.PhxMeleeWeaponSettings.GetMeleeSpec
// 0x0038 (0x0038 - 0x0000)
struct PhxMeleeWeaponSettings_GetMeleeSpec final
{
public:
	struct FMeleeWeaponSettings                   ReturnValue;                                       // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMeleeWeaponSettings_GetMeleeSpec) == 0x000008, "Wrong alignment on PhxMeleeWeaponSettings_GetMeleeSpec");
static_assert(sizeof(PhxMeleeWeaponSettings_GetMeleeSpec) == 0x000038, "Wrong size on PhxMeleeWeaponSettings_GetMeleeSpec");
static_assert(offsetof(PhxMeleeWeaponSettings_GetMeleeSpec, ReturnValue) == 0x000000, "Member 'PhxMeleeWeaponSettings_GetMeleeSpec::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerTriggerBox.HandleActorBeginOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerTriggerBox_HandleActorBeginOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerTriggerBox_HandleActorBeginOverlap) == 0x000008, "Wrong alignment on PhxPlayerTriggerBox_HandleActorBeginOverlap");
static_assert(sizeof(PhxPlayerTriggerBox_HandleActorBeginOverlap) == 0x000010, "Wrong size on PhxPlayerTriggerBox_HandleActorBeginOverlap");
static_assert(offsetof(PhxPlayerTriggerBox_HandleActorBeginOverlap, OverlappedActor) == 0x000000, "Member 'PhxPlayerTriggerBox_HandleActorBeginOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxPlayerTriggerBox_HandleActorBeginOverlap, OtherActor) == 0x000008, "Member 'PhxPlayerTriggerBox_HandleActorBeginOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxPlayerTriggerBox.HandleActorEndOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerTriggerBox_HandleActorEndOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerTriggerBox_HandleActorEndOverlap) == 0x000008, "Wrong alignment on PhxPlayerTriggerBox_HandleActorEndOverlap");
static_assert(sizeof(PhxPlayerTriggerBox_HandleActorEndOverlap) == 0x000010, "Wrong size on PhxPlayerTriggerBox_HandleActorEndOverlap");
static_assert(offsetof(PhxPlayerTriggerBox_HandleActorEndOverlap, OverlappedActor) == 0x000000, "Member 'PhxPlayerTriggerBox_HandleActorEndOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxPlayerTriggerBox_HandleActorEndOverlap, OtherActor) == 0x000008, "Member 'PhxPlayerTriggerBox_HandleActorEndOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxCharacterMovementComponent.OnMontageBlendingOut
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterMovementComponent_OnMontageBlendingOut final
{
public:
	class UAnimMontage*                           InMontage;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInInterrupted;                                    // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterMovementComponent_OnMontageBlendingOut) == 0x000008, "Wrong alignment on PhxCharacterMovementComponent_OnMontageBlendingOut");
static_assert(sizeof(PhxCharacterMovementComponent_OnMontageBlendingOut) == 0x000010, "Wrong size on PhxCharacterMovementComponent_OnMontageBlendingOut");
static_assert(offsetof(PhxCharacterMovementComponent_OnMontageBlendingOut, InMontage) == 0x000000, "Member 'PhxCharacterMovementComponent_OnMontageBlendingOut::InMontage' has a wrong offset!");
static_assert(offsetof(PhxCharacterMovementComponent_OnMontageBlendingOut, bInInterrupted) == 0x000008, "Member 'PhxCharacterMovementComponent_OnMontageBlendingOut::bInInterrupted' has a wrong offset!");

// Function Phoenix.PhxCharacterMovementComponent.OnMontageEnded
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterMovementComponent_OnMontageEnded final
{
public:
	class UAnimMontage*                           InMontage;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInInterrupted;                                    // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterMovementComponent_OnMontageEnded) == 0x000008, "Wrong alignment on PhxCharacterMovementComponent_OnMontageEnded");
static_assert(sizeof(PhxCharacterMovementComponent_OnMontageEnded) == 0x000010, "Wrong size on PhxCharacterMovementComponent_OnMontageEnded");
static_assert(offsetof(PhxCharacterMovementComponent_OnMontageEnded, InMontage) == 0x000000, "Member 'PhxCharacterMovementComponent_OnMontageEnded::InMontage' has a wrong offset!");
static_assert(offsetof(PhxCharacterMovementComponent_OnMontageEnded, bInInterrupted) == 0x000008, "Member 'PhxCharacterMovementComponent_OnMontageEnded::bInInterrupted' has a wrong offset!");

// Function Phoenix.PhxCharacterMovementComponent.OnMontageStarted
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterMovementComponent_OnMontageStarted final
{
public:
	class UAnimMontage*                           InMontage;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterMovementComponent_OnMontageStarted) == 0x000008, "Wrong alignment on PhxCharacterMovementComponent_OnMontageStarted");
static_assert(sizeof(PhxCharacterMovementComponent_OnMontageStarted) == 0x000008, "Wrong size on PhxCharacterMovementComponent_OnMontageStarted");
static_assert(offsetof(PhxCharacterMovementComponent_OnMontageStarted, InMontage) == 0x000000, "Member 'PhxCharacterMovementComponent_OnMontageStarted::InMontage' has a wrong offset!");

// Function Phoenix.PhxAIMovementComponent.OnBumpingCapsuleBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap) == 0x000008, "Wrong alignment on PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap");
static_assert(sizeof(PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap) == 0x0000A8, "Wrong size on PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap");
static_assert(offsetof(PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap, OverlappedComponent) == 0x000000, "Member 'PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap, OtherActor) == 0x000008, "Member 'PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap, OtherComp) == 0x000010, "Member 'PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap, bFromSweep) == 0x00001C, "Member 'PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap, SweepResult) == 0x000020, "Member 'PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxScriptedEventCharacter.RequestPositionSyncingWithScriptedEvent
// 0x0010 (0x0010 - 0x0000)
struct PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent final
{
public:
	class APhxScriptedEventActor*                 ScriptedEvent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BindingTag;                                        // 0x0008(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent) == 0x000008, "Wrong alignment on PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent");
static_assert(sizeof(PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent) == 0x000010, "Wrong size on PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent");
static_assert(offsetof(PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent, ScriptedEvent) == 0x000000, "Member 'PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent::ScriptedEvent' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent, BindingTag) == 0x000008, "Member 'PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent::BindingTag' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetGroupWidget.SetDetailTimingVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetGroupWidget_SetDetailTimingVisibility final
{
public:
	ESlateVisibility                              Vis;                                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetGroupWidget_SetDetailTimingVisibility) == 0x000001, "Wrong alignment on PhxAssetBudgetGroupWidget_SetDetailTimingVisibility");
static_assert(sizeof(PhxAssetBudgetGroupWidget_SetDetailTimingVisibility) == 0x000001, "Wrong size on PhxAssetBudgetGroupWidget_SetDetailTimingVisibility");
static_assert(offsetof(PhxAssetBudgetGroupWidget_SetDetailTimingVisibility, Vis) == 0x000000, "Member 'PhxAssetBudgetGroupWidget_SetDetailTimingVisibility::Vis' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetGroupWidget.SetDrawsStatsVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetGroupWidget_SetDrawsStatsVisibility final
{
public:
	ESlateVisibility                              Vis;                                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetGroupWidget_SetDrawsStatsVisibility) == 0x000001, "Wrong alignment on PhxAssetBudgetGroupWidget_SetDrawsStatsVisibility");
static_assert(sizeof(PhxAssetBudgetGroupWidget_SetDrawsStatsVisibility) == 0x000001, "Wrong size on PhxAssetBudgetGroupWidget_SetDrawsStatsVisibility");
static_assert(offsetof(PhxAssetBudgetGroupWidget_SetDrawsStatsVisibility, Vis) == 0x000000, "Member 'PhxAssetBudgetGroupWidget_SetDrawsStatsVisibility::Vis' has a wrong offset!");

// Function Phoenix.PhxAchievementsManager.PrintAchievements
// 0x0018 (0x0018 - 0x0000)
struct PhxAchievementsManager_PrintAchievements final
{
public:
	bool                                          bResult;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class USDSAchievement*>                Achievements;                                      // 0x0008(0x0010)(ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAchievementsManager_PrintAchievements) == 0x000008, "Wrong alignment on PhxAchievementsManager_PrintAchievements");
static_assert(sizeof(PhxAchievementsManager_PrintAchievements) == 0x000018, "Wrong size on PhxAchievementsManager_PrintAchievements");
static_assert(offsetof(PhxAchievementsManager_PrintAchievements, bResult) == 0x000000, "Member 'PhxAchievementsManager_PrintAchievements::bResult' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_PrintAchievements, Achievements) == 0x000008, "Member 'PhxAchievementsManager_PrintAchievements::Achievements' has a wrong offset!");

// Function Phoenix.PhxAchievementsManager.OnDefensiveAction
// 0x0100 (0x0100 - 0x0000)
struct PhxAchievementsManager_OnDefensiveAction final
{
public:
	EReactionType                                 ReactionType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefensiveReactDirection                      ReactionDir;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2[0x6];                                        // 0x0002(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitRecord                             HitRecord;                                         // 0x0008(0x00F8)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAchievementsManager_OnDefensiveAction) == 0x000008, "Wrong alignment on PhxAchievementsManager_OnDefensiveAction");
static_assert(sizeof(PhxAchievementsManager_OnDefensiveAction) == 0x000100, "Wrong size on PhxAchievementsManager_OnDefensiveAction");
static_assert(offsetof(PhxAchievementsManager_OnDefensiveAction, ReactionType) == 0x000000, "Member 'PhxAchievementsManager_OnDefensiveAction::ReactionType' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnDefensiveAction, ReactionDir) == 0x000001, "Member 'PhxAchievementsManager_OnDefensiveAction::ReactionDir' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnDefensiveAction, HitRecord) == 0x000008, "Member 'PhxAchievementsManager_OnDefensiveAction::HitRecord' has a wrong offset!");

// Function Phoenix.PhxAchievementsManager.OnEnemyBodyPartDead
// 0x0028 (0x0028 - 0x0000)
struct PhxAchievementsManager_OnEnemyBodyPartDead final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<EPhxBodyPartType>                      KilledParts;                                       // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
	class AActor*                                 InstigatorActor;                                   // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAchievementsManager_OnEnemyBodyPartDead) == 0x000008, "Wrong alignment on PhxAchievementsManager_OnEnemyBodyPartDead");
static_assert(sizeof(PhxAchievementsManager_OnEnemyBodyPartDead) == 0x000028, "Wrong size on PhxAchievementsManager_OnEnemyBodyPartDead");
static_assert(offsetof(PhxAchievementsManager_OnEnemyBodyPartDead, GameStateManager) == 0x000000, "Member 'PhxAchievementsManager_OnEnemyBodyPartDead::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyBodyPartDead, Enemy) == 0x000008, "Member 'PhxAchievementsManager_OnEnemyBodyPartDead::Enemy' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyBodyPartDead, KilledParts) == 0x000010, "Member 'PhxAchievementsManager_OnEnemyBodyPartDead::KilledParts' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyBodyPartDead, InstigatorActor) == 0x000020, "Member 'PhxAchievementsManager_OnEnemyBodyPartDead::InstigatorActor' has a wrong offset!");

// Function Phoenix.PhxAchievementsManager.OnEnemyDeath
// 0x0018 (0x0018 - 0x0000)
struct PhxAchievementsManager_OnEnemyDeath final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAchievementsManager_OnEnemyDeath) == 0x000008, "Wrong alignment on PhxAchievementsManager_OnEnemyDeath");
static_assert(sizeof(PhxAchievementsManager_OnEnemyDeath) == 0x000018, "Wrong size on PhxAchievementsManager_OnEnemyDeath");
static_assert(offsetof(PhxAchievementsManager_OnEnemyDeath, GameStateManager) == 0x000000, "Member 'PhxAchievementsManager_OnEnemyDeath::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyDeath, Enemy) == 0x000008, "Member 'PhxAchievementsManager_OnEnemyDeath::Enemy' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyDeath, KillerController) == 0x000010, "Member 'PhxAchievementsManager_OnEnemyDeath::KillerController' has a wrong offset!");

// Function Phoenix.PhxAchievementsManager.OnEnemyGRPGrabbed
// 0x0010 (0x0010 - 0x0000)
struct PhxAchievementsManager_OnEnemyGRPGrabbed final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAchievementsManager_OnEnemyGRPGrabbed) == 0x000008, "Wrong alignment on PhxAchievementsManager_OnEnemyGRPGrabbed");
static_assert(sizeof(PhxAchievementsManager_OnEnemyGRPGrabbed) == 0x000010, "Wrong size on PhxAchievementsManager_OnEnemyGRPGrabbed");
static_assert(offsetof(PhxAchievementsManager_OnEnemyGRPGrabbed, GameStateManager) == 0x000000, "Member 'PhxAchievementsManager_OnEnemyGRPGrabbed::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyGRPGrabbed, Enemy) == 0x000008, "Member 'PhxAchievementsManager_OnEnemyGRPGrabbed::Enemy' has a wrong offset!");

// Function Phoenix.PhxAchievementsManager.OnEnemyKilledByHazard
// 0x0010 (0x0010 - 0x0000)
struct PhxAchievementsManager_OnEnemyKilledByHazard final
{
public:
	class APhxAICharacter*                        Enemy;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AEnvironmentalHazard*                   HazardActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAchievementsManager_OnEnemyKilledByHazard) == 0x000008, "Wrong alignment on PhxAchievementsManager_OnEnemyKilledByHazard");
static_assert(sizeof(PhxAchievementsManager_OnEnemyKilledByHazard) == 0x000010, "Wrong size on PhxAchievementsManager_OnEnemyKilledByHazard");
static_assert(offsetof(PhxAchievementsManager_OnEnemyKilledByHazard, Enemy) == 0x000000, "Member 'PhxAchievementsManager_OnEnemyKilledByHazard::Enemy' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyKilledByHazard, HazardActor) == 0x000008, "Member 'PhxAchievementsManager_OnEnemyKilledByHazard::HazardActor' has a wrong offset!");

// Function Phoenix.PhxAchievementsManager.OnEnemyKilledByMeleeWeapon
// 0x0020 (0x0020 - 0x0000)
struct PhxAchievementsManager_OnEnemyKilledByMeleeWeapon final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AMeleeWeapon*                           Weapon;                                            // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxMeleeAttackDefinition*              AttackDef;                                         // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAchievementsManager_OnEnemyKilledByMeleeWeapon) == 0x000008, "Wrong alignment on PhxAchievementsManager_OnEnemyKilledByMeleeWeapon");
static_assert(sizeof(PhxAchievementsManager_OnEnemyKilledByMeleeWeapon) == 0x000020, "Wrong size on PhxAchievementsManager_OnEnemyKilledByMeleeWeapon");
static_assert(offsetof(PhxAchievementsManager_OnEnemyKilledByMeleeWeapon, GameStateManager) == 0x000000, "Member 'PhxAchievementsManager_OnEnemyKilledByMeleeWeapon::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyKilledByMeleeWeapon, Enemy) == 0x000008, "Member 'PhxAchievementsManager_OnEnemyKilledByMeleeWeapon::Enemy' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyKilledByMeleeWeapon, Weapon) == 0x000010, "Member 'PhxAchievementsManager_OnEnemyKilledByMeleeWeapon::Weapon' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnEnemyKilledByMeleeWeapon, AttackDef) == 0x000018, "Member 'PhxAchievementsManager_OnEnemyKilledByMeleeWeapon::AttackDef' has a wrong offset!");

// Function Phoenix.PhxAchievementsManager.OnPlayerDeath
// 0x0020 (0x0020 - 0x0000)
struct PhxAchievementsManager_OnPlayerDeath final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAchievementsManager_OnPlayerDeath) == 0x000008, "Wrong alignment on PhxAchievementsManager_OnPlayerDeath");
static_assert(sizeof(PhxAchievementsManager_OnPlayerDeath) == 0x000020, "Wrong size on PhxAchievementsManager_OnPlayerDeath");
static_assert(offsetof(PhxAchievementsManager_OnPlayerDeath, DeadCharacter) == 0x000000, "Member 'PhxAchievementsManager_OnPlayerDeath::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnPlayerDeath, KillerActor) == 0x000008, "Member 'PhxAchievementsManager_OnPlayerDeath::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnPlayerDeath, KillerController) == 0x000010, "Member 'PhxAchievementsManager_OnPlayerDeath::KillerController' has a wrong offset!");
static_assert(offsetof(PhxAchievementsManager_OnPlayerDeath, KillingBlowHealthDelta) == 0x000018, "Member 'PhxAchievementsManager_OnPlayerDeath::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxAcousticPortalComponent.OnOverlapBegin
// 0x00A8 (0x00A8 - 0x0000)
struct PhxAcousticPortalComponent_OnOverlapBegin final
{
public:
	class UPrimitiveComponent*                    OverlappedComp;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAcousticPortalComponent_OnOverlapBegin) == 0x000008, "Wrong alignment on PhxAcousticPortalComponent_OnOverlapBegin");
static_assert(sizeof(PhxAcousticPortalComponent_OnOverlapBegin) == 0x0000A8, "Wrong size on PhxAcousticPortalComponent_OnOverlapBegin");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapBegin, OverlappedComp) == 0x000000, "Member 'PhxAcousticPortalComponent_OnOverlapBegin::OverlappedComp' has a wrong offset!");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapBegin, OtherActor) == 0x000008, "Member 'PhxAcousticPortalComponent_OnOverlapBegin::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapBegin, OtherComp) == 0x000010, "Member 'PhxAcousticPortalComponent_OnOverlapBegin::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapBegin, OtherBodyIndex) == 0x000018, "Member 'PhxAcousticPortalComponent_OnOverlapBegin::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapBegin, bFromSweep) == 0x00001C, "Member 'PhxAcousticPortalComponent_OnOverlapBegin::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapBegin, SweepResult) == 0x000020, "Member 'PhxAcousticPortalComponent_OnOverlapBegin::SweepResult' has a wrong offset!");

// Function Phoenix.PhxAcousticPortalComponent.OnOverlapEnd
// 0x0020 (0x0020 - 0x0000)
struct PhxAcousticPortalComponent_OnOverlapEnd final
{
public:
	class UPrimitiveComponent*                    OverlappedComp;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAcousticPortalComponent_OnOverlapEnd) == 0x000008, "Wrong alignment on PhxAcousticPortalComponent_OnOverlapEnd");
static_assert(sizeof(PhxAcousticPortalComponent_OnOverlapEnd) == 0x000020, "Wrong size on PhxAcousticPortalComponent_OnOverlapEnd");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapEnd, OverlappedComp) == 0x000000, "Member 'PhxAcousticPortalComponent_OnOverlapEnd::OverlappedComp' has a wrong offset!");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapEnd, OtherActor) == 0x000008, "Member 'PhxAcousticPortalComponent_OnOverlapEnd::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapEnd, OtherComp) == 0x000010, "Member 'PhxAcousticPortalComponent_OnOverlapEnd::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxAcousticPortalComponent_OnOverlapEnd, OtherBodyIndex) == 0x000018, "Member 'PhxAcousticPortalComponent_OnOverlapEnd::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PhxAcousticPortalComponent.ScaleToPercent
// 0x0008 (0x0008 - 0x0000)
struct PhxAcousticPortalComponent_ScaleToPercent final
{
public:
	float                                         TargetPercent;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimeToOpen;                                        // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAcousticPortalComponent_ScaleToPercent) == 0x000004, "Wrong alignment on PhxAcousticPortalComponent_ScaleToPercent");
static_assert(sizeof(PhxAcousticPortalComponent_ScaleToPercent) == 0x000008, "Wrong size on PhxAcousticPortalComponent_ScaleToPercent");
static_assert(offsetof(PhxAcousticPortalComponent_ScaleToPercent, TargetPercent) == 0x000000, "Member 'PhxAcousticPortalComponent_ScaleToPercent::TargetPercent' has a wrong offset!");
static_assert(offsetof(PhxAcousticPortalComponent_ScaleToPercent, TimeToOpen) == 0x000004, "Member 'PhxAcousticPortalComponent_ScaleToPercent::TimeToOpen' has a wrong offset!");

// Function Phoenix.PhxAIAbilityTask_DefaultAttack.HandleAnimNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxAIAbilityTask_DefaultAttack_HandleAnimNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIAbilityTask_DefaultAttack_HandleAnimNotifyReceived) == 0x000008, "Wrong alignment on PhxAIAbilityTask_DefaultAttack_HandleAnimNotifyReceived");
static_assert(sizeof(PhxAIAbilityTask_DefaultAttack_HandleAnimNotifyReceived) == 0x000008, "Wrong size on PhxAIAbilityTask_DefaultAttack_HandleAnimNotifyReceived");
static_assert(offsetof(PhxAIAbilityTask_DefaultAttack_HandleAnimNotifyReceived, Notify) == 0x000000, "Member 'PhxAIAbilityTask_DefaultAttack_HandleAnimNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxAIVirus.BP_OnRangedWeaponAimedAt
// 0x0008 (0x0008 - 0x0000)
struct PhxAIVirus_BP_OnRangedWeaponAimedAt final
{
public:
	class APhxCharacter*                          AimingCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIVirus_BP_OnRangedWeaponAimedAt) == 0x000008, "Wrong alignment on PhxAIVirus_BP_OnRangedWeaponAimedAt");
static_assert(sizeof(PhxAIVirus_BP_OnRangedWeaponAimedAt) == 0x000008, "Wrong size on PhxAIVirus_BP_OnRangedWeaponAimedAt");
static_assert(offsetof(PhxAIVirus_BP_OnRangedWeaponAimedAt, AimingCharacter) == 0x000000, "Member 'PhxAIVirus_BP_OnRangedWeaponAimedAt::AimingCharacter' has a wrong offset!");

// Function Phoenix.PhxAIVirus.BP_OnRangedWeaponAimedAway
// 0x0008 (0x0008 - 0x0000)
struct PhxAIVirus_BP_OnRangedWeaponAimedAway final
{
public:
	class APhxCharacter*                          AimingCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIVirus_BP_OnRangedWeaponAimedAway) == 0x000008, "Wrong alignment on PhxAIVirus_BP_OnRangedWeaponAimedAway");
static_assert(sizeof(PhxAIVirus_BP_OnRangedWeaponAimedAway) == 0x000008, "Wrong size on PhxAIVirus_BP_OnRangedWeaponAimedAway");
static_assert(offsetof(PhxAIVirus_BP_OnRangedWeaponAimedAway, AimingCharacter) == 0x000000, "Member 'PhxAIVirus_BP_OnRangedWeaponAimedAway::AimingCharacter' has a wrong offset!");

// Function Phoenix.PhxAIVirus.OnKillAnimCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxAIVirus_OnKillAnimCompleted final
{
public:
	class UAnimMontage*                           Montage;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInterrupted;                                      // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIVirus_OnKillAnimCompleted) == 0x000008, "Wrong alignment on PhxAIVirus_OnKillAnimCompleted");
static_assert(sizeof(PhxAIVirus_OnKillAnimCompleted) == 0x000010, "Wrong size on PhxAIVirus_OnKillAnimCompleted");
static_assert(offsetof(PhxAIVirus_OnKillAnimCompleted, Montage) == 0x000000, "Member 'PhxAIVirus_OnKillAnimCompleted::Montage' has a wrong offset!");
static_assert(offsetof(PhxAIVirus_OnKillAnimCompleted, bInterrupted) == 0x000008, "Member 'PhxAIVirus_OnKillAnimCompleted::bInterrupted' has a wrong offset!");

// Function Phoenix.PhxAIVirus.OnOwningCharacterDestroyed
// 0x0008 (0x0008 - 0x0000)
struct PhxAIVirus_OnOwningCharacterDestroyed final
{
public:
	class AActor*                                 DestroyedActor;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIVirus_OnOwningCharacterDestroyed) == 0x000008, "Wrong alignment on PhxAIVirus_OnOwningCharacterDestroyed");
static_assert(sizeof(PhxAIVirus_OnOwningCharacterDestroyed) == 0x000008, "Wrong size on PhxAIVirus_OnOwningCharacterDestroyed");
static_assert(offsetof(PhxAIVirus_OnOwningCharacterDestroyed, DestroyedActor) == 0x000000, "Member 'PhxAIVirus_OnOwningCharacterDestroyed::DestroyedActor' has a wrong offset!");

// Function Phoenix.PhxAIVirus.OnOwningCharacterHidden
// 0x0008 (0x0008 - 0x0000)
struct PhxAIVirus_OnOwningCharacterHidden final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIVirus_OnOwningCharacterHidden) == 0x000008, "Wrong alignment on PhxAIVirus_OnOwningCharacterHidden");
static_assert(sizeof(PhxAIVirus_OnOwningCharacterHidden) == 0x000008, "Wrong size on PhxAIVirus_OnOwningCharacterHidden");
static_assert(offsetof(PhxAIVirus_OnOwningCharacterHidden, Character) == 0x000000, "Member 'PhxAIVirus_OnOwningCharacterHidden::Character' has a wrong offset!");

// Function Phoenix.PhxAIVirus.OnOwningCharacterUnhidden
// 0x0008 (0x0008 - 0x0000)
struct PhxAIVirus_OnOwningCharacterUnhidden final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIVirus_OnOwningCharacterUnhidden) == 0x000008, "Wrong alignment on PhxAIVirus_OnOwningCharacterUnhidden");
static_assert(sizeof(PhxAIVirus_OnOwningCharacterUnhidden) == 0x000008, "Wrong size on PhxAIVirus_OnOwningCharacterUnhidden");
static_assert(offsetof(PhxAIVirus_OnOwningCharacterUnhidden, Character) == 0x000000, "Member 'PhxAIVirus_OnOwningCharacterUnhidden::Character' has a wrong offset!");

// Function Phoenix.PhxAIVirus.OnRetractAnimCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxAIVirus_OnRetractAnimCompleted final
{
public:
	class UAnimMontage*                           Montage;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInterrupted;                                      // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIVirus_OnRetractAnimCompleted) == 0x000008, "Wrong alignment on PhxAIVirus_OnRetractAnimCompleted");
static_assert(sizeof(PhxAIVirus_OnRetractAnimCompleted) == 0x000010, "Wrong size on PhxAIVirus_OnRetractAnimCompleted");
static_assert(offsetof(PhxAIVirus_OnRetractAnimCompleted, Montage) == 0x000000, "Member 'PhxAIVirus_OnRetractAnimCompleted::Montage' has a wrong offset!");
static_assert(offsetof(PhxAIVirus_OnRetractAnimCompleted, bInterrupted) == 0x000008, "Member 'PhxAIVirus_OnRetractAnimCompleted::bInterrupted' has a wrong offset!");

// Function Phoenix.PhxAutomationBlueprintFunctionLibrary.InputAxis
// 0x0014 (0x0014 - 0x0000)
struct PhxAutomationBlueprintFunctionLibrary_InputAxis final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Delta;                                             // 0x0008(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DeltaTime;                                         // 0x000C(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumSamples;                                        // 0x0010(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutomationBlueprintFunctionLibrary_InputAxis) == 0x000004, "Wrong alignment on PhxAutomationBlueprintFunctionLibrary_InputAxis");
static_assert(sizeof(PhxAutomationBlueprintFunctionLibrary_InputAxis) == 0x000014, "Wrong size on PhxAutomationBlueprintFunctionLibrary_InputAxis");
static_assert(offsetof(PhxAutomationBlueprintFunctionLibrary_InputAxis, ActionName) == 0x000000, "Member 'PhxAutomationBlueprintFunctionLibrary_InputAxis::ActionName' has a wrong offset!");
static_assert(offsetof(PhxAutomationBlueprintFunctionLibrary_InputAxis, Delta) == 0x000008, "Member 'PhxAutomationBlueprintFunctionLibrary_InputAxis::Delta' has a wrong offset!");
static_assert(offsetof(PhxAutomationBlueprintFunctionLibrary_InputAxis, DeltaTime) == 0x00000C, "Member 'PhxAutomationBlueprintFunctionLibrary_InputAxis::DeltaTime' has a wrong offset!");
static_assert(offsetof(PhxAutomationBlueprintFunctionLibrary_InputAxis, NumSamples) == 0x000010, "Member 'PhxAutomationBlueprintFunctionLibrary_InputAxis::NumSamples' has a wrong offset!");

// Function Phoenix.PhxAutomationBlueprintFunctionLibrary.InputKey
// 0x0010 (0x0010 - 0x0000)
struct PhxAutomationBlueprintFunctionLibrary_InputKey final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputEvent                                   InputEvent;                                        // 0x0008(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AmountDepressed;                                   // 0x000C(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutomationBlueprintFunctionLibrary_InputKey) == 0x000004, "Wrong alignment on PhxAutomationBlueprintFunctionLibrary_InputKey");
static_assert(sizeof(PhxAutomationBlueprintFunctionLibrary_InputKey) == 0x000010, "Wrong size on PhxAutomationBlueprintFunctionLibrary_InputKey");
static_assert(offsetof(PhxAutomationBlueprintFunctionLibrary_InputKey, ActionName) == 0x000000, "Member 'PhxAutomationBlueprintFunctionLibrary_InputKey::ActionName' has a wrong offset!");
static_assert(offsetof(PhxAutomationBlueprintFunctionLibrary_InputKey, InputEvent) == 0x000008, "Member 'PhxAutomationBlueprintFunctionLibrary_InputKey::InputEvent' has a wrong offset!");
static_assert(offsetof(PhxAutomationBlueprintFunctionLibrary_InputKey, AmountDepressed) == 0x00000C, "Member 'PhxAutomationBlueprintFunctionLibrary_InputKey::AmountDepressed' has a wrong offset!");

// Function Phoenix.PhxAutomationBlueprintFunctionLibrary.TeleportPlayerToLocation
// 0x0018 (0x0018 - 0x0000)
struct PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation final
{
public:
	struct FVector                                Location;                                          // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               Rotation;                                          // 0x000C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation) == 0x000004, "Wrong alignment on PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation");
static_assert(sizeof(PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation) == 0x000018, "Wrong size on PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation");
static_assert(offsetof(PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation, Location) == 0x000000, "Member 'PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation::Location' has a wrong offset!");
static_assert(offsetof(PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation, Rotation) == 0x00000C, "Member 'PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation::Rotation' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxAudioSystem_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAudioSystem*                        ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_Get) == 0x000008, "Wrong alignment on PhxAudioSystem_Get");
static_assert(sizeof(PhxAudioSystem_Get) == 0x000010, "Wrong size on PhxAudioSystem_Get");
static_assert(offsetof(PhxAudioSystem_Get, WorldContextObject) == 0x000000, "Member 'PhxAudioSystem_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAudioSystem_Get, ReturnValue) == 0x000008, "Member 'PhxAudioSystem_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.GetRoomAndPortalVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_GetRoomAndPortalVisibility final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_GetRoomAndPortalVisibility) == 0x000001, "Wrong alignment on PhxAudioSystem_GetRoomAndPortalVisibility");
static_assert(sizeof(PhxAudioSystem_GetRoomAndPortalVisibility) == 0x000001, "Wrong size on PhxAudioSystem_GetRoomAndPortalVisibility");
static_assert(offsetof(PhxAudioSystem_GetRoomAndPortalVisibility, ReturnValue) == 0x000000, "Member 'PhxAudioSystem_GetRoomAndPortalVisibility::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.GetRTPC
// 0x0018 (0x0018 - 0x0000)
struct PhxAudioSystem_GetRTPC final
{
public:
	class UAkRtpc*                                RTPC;                                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkComponent*                           SoundComp;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0010(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAudioSystem_GetRTPC) == 0x000008, "Wrong alignment on PhxAudioSystem_GetRTPC");
static_assert(sizeof(PhxAudioSystem_GetRTPC) == 0x000018, "Wrong size on PhxAudioSystem_GetRTPC");
static_assert(offsetof(PhxAudioSystem_GetRTPC, RTPC) == 0x000000, "Member 'PhxAudioSystem_GetRTPC::RTPC' has a wrong offset!");
static_assert(offsetof(PhxAudioSystem_GetRTPC, SoundComp) == 0x000008, "Member 'PhxAudioSystem_GetRTPC::SoundComp' has a wrong offset!");
static_assert(offsetof(PhxAudioSystem_GetRTPC, ReturnValue) == 0x000010, "Member 'PhxAudioSystem_GetRTPC::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetDialogueLanguage
// 0x0010 (0x0010 - 0x0000)
struct PhxAudioSystem_SetDialogueLanguage final
{
public:
	class FString                                 Language;                                          // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetDialogueLanguage) == 0x000008, "Wrong alignment on PhxAudioSystem_SetDialogueLanguage");
static_assert(sizeof(PhxAudioSystem_SetDialogueLanguage) == 0x000010, "Wrong size on PhxAudioSystem_SetDialogueLanguage");
static_assert(offsetof(PhxAudioSystem_SetDialogueLanguage, Language) == 0x000000, "Member 'PhxAudioSystem_SetDialogueLanguage::Language' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetMuted
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_SetMuted final
{
public:
	bool                                          Muted;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetMuted) == 0x000001, "Wrong alignment on PhxAudioSystem_SetMuted");
static_assert(sizeof(PhxAudioSystem_SetMuted) == 0x000001, "Wrong size on PhxAudioSystem_SetMuted");
static_assert(offsetof(PhxAudioSystem_SetMuted, Muted) == 0x000000, "Member 'PhxAudioSystem_SetMuted::Muted' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetRoomAndPortalVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_SetRoomAndPortalVisibility final
{
public:
	bool                                          Enabled;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetRoomAndPortalVisibility) == 0x000001, "Wrong alignment on PhxAudioSystem_SetRoomAndPortalVisibility");
static_assert(sizeof(PhxAudioSystem_SetRoomAndPortalVisibility) == 0x000001, "Wrong size on PhxAudioSystem_SetRoomAndPortalVisibility");
static_assert(offsetof(PhxAudioSystem_SetRoomAndPortalVisibility, Enabled) == 0x000000, "Member 'PhxAudioSystem_SetRoomAndPortalVisibility::Enabled' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetRTPC
// 0x0018 (0x0018 - 0x0000)
struct PhxAudioSystem_SetRTPC final
{
public:
	class UAkRtpc*                                RTPC;                                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RTPCValue;                                         // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UAkComponent*                           SoundComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetRTPC) == 0x000008, "Wrong alignment on PhxAudioSystem_SetRTPC");
static_assert(sizeof(PhxAudioSystem_SetRTPC) == 0x000018, "Wrong size on PhxAudioSystem_SetRTPC");
static_assert(offsetof(PhxAudioSystem_SetRTPC, RTPC) == 0x000000, "Member 'PhxAudioSystem_SetRTPC::RTPC' has a wrong offset!");
static_assert(offsetof(PhxAudioSystem_SetRTPC, RTPCValue) == 0x000008, "Member 'PhxAudioSystem_SetRTPC::RTPCValue' has a wrong offset!");
static_assert(offsetof(PhxAudioSystem_SetRTPC, SoundComp) == 0x000010, "Member 'PhxAudioSystem_SetRTPC::SoundComp' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.GetPlayerRadioVolume
// 0x000C (0x000C - 0x0000)
struct PhxAudioSystem_GetPlayerRadioVolume final
{
public:
	float                                         MinOutValue;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxOutValue;                                       // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_GetPlayerRadioVolume) == 0x000004, "Wrong alignment on PhxAudioSystem_GetPlayerRadioVolume");
static_assert(sizeof(PhxAudioSystem_GetPlayerRadioVolume) == 0x00000C, "Wrong size on PhxAudioSystem_GetPlayerRadioVolume");
static_assert(offsetof(PhxAudioSystem_GetPlayerRadioVolume, MinOutValue) == 0x000000, "Member 'PhxAudioSystem_GetPlayerRadioVolume::MinOutValue' has a wrong offset!");
static_assert(offsetof(PhxAudioSystem_GetPlayerRadioVolume, MaxOutValue) == 0x000004, "Member 'PhxAudioSystem_GetPlayerRadioVolume::MaxOutValue' has a wrong offset!");
static_assert(offsetof(PhxAudioSystem_GetPlayerRadioVolume, ReturnValue) == 0x000008, "Member 'PhxAudioSystem_GetPlayerRadioVolume::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.OnRumbleEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_OnRumbleEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_OnRumbleEnabled) == 0x000001, "Wrong alignment on PhxAudioSystem_OnRumbleEnabled");
static_assert(sizeof(PhxAudioSystem_OnRumbleEnabled) == 0x000001, "Wrong size on PhxAudioSystem_OnRumbleEnabled");
static_assert(offsetof(PhxAudioSystem_OnRumbleEnabled, bEnabled) == 0x000000, "Member 'PhxAudioSystem_OnRumbleEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.PostGlobalEvent
// 0x0008 (0x0008 - 0x0000)
struct PhxAudioSystem_PostGlobalEvent final
{
public:
	class UAkAudioEvent*                          Event;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_PostGlobalEvent) == 0x000008, "Wrong alignment on PhxAudioSystem_PostGlobalEvent");
static_assert(sizeof(PhxAudioSystem_PostGlobalEvent) == 0x000008, "Wrong size on PhxAudioSystem_PostGlobalEvent");
static_assert(offsetof(PhxAudioSystem_PostGlobalEvent, Event) == 0x000000, "Member 'PhxAudioSystem_PostGlobalEvent::Event' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetAkGeoEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_SetAkGeoEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetAkGeoEnabled) == 0x000001, "Wrong alignment on PhxAudioSystem_SetAkGeoEnabled");
static_assert(sizeof(PhxAudioSystem_SetAkGeoEnabled) == 0x000001, "Wrong size on PhxAudioSystem_SetAkGeoEnabled");
static_assert(offsetof(PhxAudioSystem_SetAkGeoEnabled, bEnabled) == 0x000000, "Member 'PhxAudioSystem_SetAkGeoEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetDialogueEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_SetDialogueEnabled final
{
public:
	bool                                          Enabled;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetDialogueEnabled) == 0x000001, "Wrong alignment on PhxAudioSystem_SetDialogueEnabled");
static_assert(sizeof(PhxAudioSystem_SetDialogueEnabled) == 0x000001, "Wrong size on PhxAudioSystem_SetDialogueEnabled");
static_assert(offsetof(PhxAudioSystem_SetDialogueEnabled, Enabled) == 0x000000, "Member 'PhxAudioSystem_SetDialogueEnabled::Enabled' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetDialogueVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxAudioSystem_SetDialogueVolume final
{
public:
	float                                         Intensity;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetDialogueVolume) == 0x000004, "Wrong alignment on PhxAudioSystem_SetDialogueVolume");
static_assert(sizeof(PhxAudioSystem_SetDialogueVolume) == 0x000004, "Wrong size on PhxAudioSystem_SetDialogueVolume");
static_assert(offsetof(PhxAudioSystem_SetDialogueVolume, Intensity) == 0x000000, "Member 'PhxAudioSystem_SetDialogueVolume::Intensity' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetMusicEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_SetMusicEnabled final
{
public:
	bool                                          Enabled;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetMusicEnabled) == 0x000001, "Wrong alignment on PhxAudioSystem_SetMusicEnabled");
static_assert(sizeof(PhxAudioSystem_SetMusicEnabled) == 0x000001, "Wrong size on PhxAudioSystem_SetMusicEnabled");
static_assert(offsetof(PhxAudioSystem_SetMusicEnabled, Enabled) == 0x000000, "Member 'PhxAudioSystem_SetMusicEnabled::Enabled' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetMusicVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxAudioSystem_SetMusicVolume final
{
public:
	float                                         Intensity;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetMusicVolume) == 0x000004, "Wrong alignment on PhxAudioSystem_SetMusicVolume");
static_assert(sizeof(PhxAudioSystem_SetMusicVolume) == 0x000004, "Wrong size on PhxAudioSystem_SetMusicVolume");
static_assert(offsetof(PhxAudioSystem_SetMusicVolume, Intensity) == 0x000000, "Member 'PhxAudioSystem_SetMusicVolume::Intensity' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetOnScreenDebugging
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_SetOnScreenDebugging final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetOnScreenDebugging) == 0x000001, "Wrong alignment on PhxAudioSystem_SetOnScreenDebugging");
static_assert(sizeof(PhxAudioSystem_SetOnScreenDebugging) == 0x000001, "Wrong size on PhxAudioSystem_SetOnScreenDebugging");
static_assert(offsetof(PhxAudioSystem_SetOnScreenDebugging, bEnabled) == 0x000000, "Member 'PhxAudioSystem_SetOnScreenDebugging::bEnabled' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetRadioBanterChannel
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_SetRadioBanterChannel final
{
public:
	EPhxRadioBanterChannel                        Channel;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetRadioBanterChannel) == 0x000001, "Wrong alignment on PhxAudioSystem_SetRadioBanterChannel");
static_assert(sizeof(PhxAudioSystem_SetRadioBanterChannel) == 0x000001, "Wrong size on PhxAudioSystem_SetRadioBanterChannel");
static_assert(offsetof(PhxAudioSystem_SetRadioBanterChannel, Channel) == 0x000000, "Member 'PhxAudioSystem_SetRadioBanterChannel::Channel' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetRadioBanterVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxAudioSystem_SetRadioBanterVolume final
{
public:
	float                                         Intensity;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetRadioBanterVolume) == 0x000004, "Wrong alignment on PhxAudioSystem_SetRadioBanterVolume");
static_assert(sizeof(PhxAudioSystem_SetRadioBanterVolume) == 0x000004, "Wrong size on PhxAudioSystem_SetRadioBanterVolume");
static_assert(offsetof(PhxAudioSystem_SetRadioBanterVolume, Intensity) == 0x000000, "Member 'PhxAudioSystem_SetRadioBanterVolume::Intensity' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetSFXEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxAudioSystem_SetSFXEnabled final
{
public:
	bool                                          Enabled;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetSFXEnabled) == 0x000001, "Wrong alignment on PhxAudioSystem_SetSFXEnabled");
static_assert(sizeof(PhxAudioSystem_SetSFXEnabled) == 0x000001, "Wrong size on PhxAudioSystem_SetSFXEnabled");
static_assert(offsetof(PhxAudioSystem_SetSFXEnabled, Enabled) == 0x000000, "Member 'PhxAudioSystem_SetSFXEnabled::Enabled' has a wrong offset!");

// Function Phoenix.PhxAudioSystem.SetSFXVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxAudioSystem_SetSFXVolume final
{
public:
	float                                         Intensity;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioSystem_SetSFXVolume) == 0x000004, "Wrong alignment on PhxAudioSystem_SetSFXVolume");
static_assert(sizeof(PhxAudioSystem_SetSFXVolume) == 0x000004, "Wrong size on PhxAudioSystem_SetSFXVolume");
static_assert(offsetof(PhxAudioSystem_SetSFXVolume, Intensity) == 0x000000, "Member 'PhxAudioSystem_SetSFXVolume::Intensity' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_DoScriptedAction.DoScriptedAction
// 0x0020 (0x0020 - 0x0000)
struct PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction final
{
public:
	struct FGameplayTag                           ActionTag;                                         // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OptionalTarget;                                    // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_DoScriptedAction* ReturnValue;                                       // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction");
static_assert(sizeof(PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction) == 0x000020, "Wrong size on PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction, ActionTag) == 0x000000, "Member 'PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction::ActionTag' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction, Character) == 0x000008, "Member 'PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction, OptionalTarget) == 0x000010, "Member 'PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction::OptionalTarget' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction, ReturnValue) == 0x000018, "Member 'PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_DoScriptedAction.HandleScriptedActionBegin
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin final
{
public:
	struct FGameplayTag                           ActionTag;                                         // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OptionalTarget;                                    // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin");
static_assert(sizeof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin) == 0x000018, "Wrong size on PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin, ActionTag) == 0x000000, "Member 'PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin::ActionTag' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin, Character) == 0x000008, "Member 'PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin, OptionalTarget) == 0x000010, "Member 'PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin::OptionalTarget' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_DoScriptedAction.HandleScriptedActionCompleted
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted final
{
public:
	struct FGameplayTag                           ActionTag;                                         // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OptionalTarget;                                    // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted");
static_assert(sizeof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted) == 0x000018, "Wrong size on PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted, ActionTag) == 0x000000, "Member 'PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted::ActionTag' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted, Character) == 0x000008, "Member 'PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted, OptionalTarget) == 0x000010, "Member 'PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted::OptionalTarget' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_DoScriptedAction.HandleScriptedActionFailed
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed final
{
public:
	struct FGameplayTag                           ActionTag;                                         // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OptionalTarget;                                    // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed");
static_assert(sizeof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed) == 0x000018, "Wrong size on PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed, ActionTag) == 0x000000, "Member 'PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed::ActionTag' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed, Character) == 0x000008, "Member 'PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed, OptionalTarget) == 0x000010, "Member 'PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed::OptionalTarget' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterEncounterNetwork
// 0x0020 (0x0020 - 0x0000)
struct PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIEncounterNetwork*                 EncounterNetwork;                                  // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDespawnAfterEntering;                             // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIMotionType                              MotionType;                                        // 0x0011(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12[0x6];                                       // 0x0012(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAIBlueprintAction_EnterEncounterNetwork* ReturnValue;                                  // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork");
static_assert(sizeof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork) == 0x000020, "Wrong size on PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork, Character) == 0x000000, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork, EncounterNetwork) == 0x000008, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork::EncounterNetwork' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork, bDespawnAfterEntering) == 0x000010, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork::bDespawnAfterEntering' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork, MotionType) == 0x000011, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork::MotionType' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork, ReturnValue) == 0x000018, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterEncounterNetworkAtNode
// 0x0020 (0x0020 - 0x0000)
struct PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIEncounterNetworkTraversalNode*    Entrance;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDespawnAfterEntering;                             // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIMotionType                              MotionType;                                        // 0x0011(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12[0x6];                                       // 0x0012(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAIBlueprintAction_EnterEncounterNetwork* ReturnValue;                                  // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode");
static_assert(sizeof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode) == 0x000020, "Wrong size on PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode, Character) == 0x000000, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode, Entrance) == 0x000008, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode::Entrance' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode, bDespawnAfterEntering) == 0x000010, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode::bDespawnAfterEntering' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode, MotionType) == 0x000011, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode::MotionType' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode, ReturnValue) == 0x000018, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterEncounterNetworkGroup
// 0x0040 (0x0040 - 0x0000)
struct PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UPhxAICharacterDefinition> AICharacterDefinition;                           // 0x0008(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIEncounterNetwork*                 EncounterNetwork;                                  // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDespawnAfterEntering;                             // 0x0038(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIMotionType                              MotionType;                                        // 0x0039(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3A[0x2];                                       // 0x003A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         OverrideMaximumEntranceDistance;                   // 0x003C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup");
static_assert(sizeof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup) == 0x000040, "Wrong size on PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup, AICharacterDefinition) == 0x000008, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup::AICharacterDefinition' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup, EncounterNetwork) == 0x000030, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup::EncounterNetwork' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup, bDespawnAfterEntering) == 0x000038, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup::bDespawnAfterEntering' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup, MotionType) == 0x000039, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup::MotionType' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup, OverrideMaximumEntranceDistance) == 0x00003C, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup::OverrideMaximumEntranceDistance' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterNearestEncounterNetwork
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDespawnAfterEntering;                             // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIMotionType                              MotionType;                                        // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxAIBlueprintAction_EnterEncounterNetwork* ReturnValue;                                  // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork");
static_assert(sizeof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork) == 0x000018, "Wrong size on PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork, Character) == 0x000000, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork, bDespawnAfterEntering) == 0x000008, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork::bDespawnAfterEntering' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork, MotionType) == 0x000009, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork::MotionType' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork, ReturnValue) == 0x000010, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterNearestEncounterNetworkGroup
// 0x0038 (0x0038 - 0x0000)
struct PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UPhxAICharacterDefinition> AICharacterDefinition;                           // 0x0008(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDespawnAfterEntering;                             // 0x0030(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIMotionType                              MotionType;                                        // 0x0031(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_32[0x6];                                       // 0x0032(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup");
static_assert(sizeof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup) == 0x000038, "Wrong size on PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup, AICharacterDefinition) == 0x000008, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup::AICharacterDefinition' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup, bDespawnAfterEntering) == 0x000030, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup::bDespawnAfterEntering' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup, MotionType) == 0x000031, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup::MotionType' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.HandleEnterEncounterNetworkCompleted
// 0x0001 (0x0001 - 0x0000)
struct PhxAIBlueprintAction_EnterEncounterNetwork_HandleEnterEncounterNetworkCompleted final
{
public:
	bool                                          bSuccess;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_EnterEncounterNetwork_HandleEnterEncounterNetworkCompleted) == 0x000001, "Wrong alignment on PhxAIBlueprintAction_EnterEncounterNetwork_HandleEnterEncounterNetworkCompleted");
static_assert(sizeof(PhxAIBlueprintAction_EnterEncounterNetwork_HandleEnterEncounterNetworkCompleted) == 0x000001, "Wrong size on PhxAIBlueprintAction_EnterEncounterNetwork_HandleEnterEncounterNetworkCompleted");
static_assert(offsetof(PhxAIBlueprintAction_EnterEncounterNetwork_HandleEnterEncounterNetworkCompleted, bSuccess) == 0x000000, "Member 'PhxAIBlueprintAction_EnterEncounterNetwork_HandleEnterEncounterNetworkCompleted::bSuccess' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_MoveWithinEncounterNetwork.MoveBetweenInternalEncounterNetworkNodes
// 0x0020 (0x0020 - 0x0000)
struct PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIEncounterNetworkWaypointNode*     FromNode;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIEncounterNetworkWaypointNode*     ToNode;                                            // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_MoveWithinEncounterNetwork* ReturnValue;                             // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes");
static_assert(sizeof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes) == 0x000020, "Wrong size on PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes");
static_assert(offsetof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes, Character) == 0x000000, "Member 'PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes, FromNode) == 0x000008, "Member 'PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes::FromNode' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes, ToNode) == 0x000010, "Member 'PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes::ToNode' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes, ReturnValue) == 0x000018, "Member 'PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_MoveWithinEncounterNetwork.MoveToInternalEncounterNetworkNode
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIEncounterNetworkWaypointNode*     Node;                                              // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_MoveWithinEncounterNetwork* ReturnValue;                             // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode");
static_assert(sizeof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode) == 0x000018, "Wrong size on PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode");
static_assert(offsetof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode, Character) == 0x000000, "Member 'PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode, Node) == 0x000008, "Member 'PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode::Node' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode, ReturnValue) == 0x000010, "Member 'PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_MoveWithinEncounterNetwork.HandleMoveWithinEncounterNetworkCompleted
// 0x0001 (0x0001 - 0x0000)
struct PhxAIBlueprintAction_MoveWithinEncounterNetwork_HandleMoveWithinEncounterNetworkCompleted final
{
public:
	bool                                          bSuccess;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_HandleMoveWithinEncounterNetworkCompleted) == 0x000001, "Wrong alignment on PhxAIBlueprintAction_MoveWithinEncounterNetwork_HandleMoveWithinEncounterNetworkCompleted");
static_assert(sizeof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_HandleMoveWithinEncounterNetworkCompleted) == 0x000001, "Wrong size on PhxAIBlueprintAction_MoveWithinEncounterNetwork_HandleMoveWithinEncounterNetworkCompleted");
static_assert(offsetof(PhxAIBlueprintAction_MoveWithinEncounterNetwork_HandleMoveWithinEncounterNetworkCompleted, bSuccess) == 0x000000, "Member 'PhxAIBlueprintAction_MoveWithinEncounterNetwork_HandleMoveWithinEncounterNetworkCompleted::bSuccess' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_UsePatrol.LeadPlayer
// 0x0030 (0x0030 - 0x0000)
struct PhxAIBlueprintAction_UsePatrol_LeadPlayer final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIPatrol*                           Patrol;                                            // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxAICompanionLeadDefinition*    LeadDefinition_0;                                  // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxAICompanionWaitDefinition*    LeadWaitDefinition_0;                              // 0x0018(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxAICompanionWaitDefinition*    BacktrackWaitDefinition_0;                         // 0x0020(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_UsePatrol*        ReturnValue;                                       // 0x0028(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_UsePatrol_LeadPlayer) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_UsePatrol_LeadPlayer");
static_assert(sizeof(PhxAIBlueprintAction_UsePatrol_LeadPlayer) == 0x000030, "Wrong size on PhxAIBlueprintAction_UsePatrol_LeadPlayer");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_LeadPlayer, Character) == 0x000000, "Member 'PhxAIBlueprintAction_UsePatrol_LeadPlayer::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_LeadPlayer, Patrol) == 0x000008, "Member 'PhxAIBlueprintAction_UsePatrol_LeadPlayer::Patrol' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_LeadPlayer, LeadDefinition_0) == 0x000010, "Member 'PhxAIBlueprintAction_UsePatrol_LeadPlayer::LeadDefinition_0' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_LeadPlayer, LeadWaitDefinition_0) == 0x000018, "Member 'PhxAIBlueprintAction_UsePatrol_LeadPlayer::LeadWaitDefinition_0' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_LeadPlayer, BacktrackWaitDefinition_0) == 0x000020, "Member 'PhxAIBlueprintAction_UsePatrol_LeadPlayer::BacktrackWaitDefinition_0' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_LeadPlayer, ReturnValue) == 0x000028, "Member 'PhxAIBlueprintAction_UsePatrol_LeadPlayer::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_UsePatrol.UsePatrol
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_UsePatrol_UsePatrol final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIPatrol*                           Patrol;                                            // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIBlueprintAction_UsePatrol*        ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintAction_UsePatrol_UsePatrol) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_UsePatrol_UsePatrol");
static_assert(sizeof(PhxAIBlueprintAction_UsePatrol_UsePatrol) == 0x000018, "Wrong size on PhxAIBlueprintAction_UsePatrol_UsePatrol");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_UsePatrol, Character) == 0x000000, "Member 'PhxAIBlueprintAction_UsePatrol_UsePatrol::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_UsePatrol, Patrol) == 0x000008, "Member 'PhxAIBlueprintAction_UsePatrol_UsePatrol::Patrol' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_UsePatrol, ReturnValue) == 0x000010, "Member 'PhxAIBlueprintAction_UsePatrol_UsePatrol::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintAction_UsePatrol.HandlePatrolDeparted
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted final
{
public:
	class APhxAICharacter*                        Occupier;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAIPatrol*                           Patrol;                                            // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInterrupted;                                      // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted) == 0x000008, "Wrong alignment on PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted");
static_assert(sizeof(PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted) == 0x000018, "Wrong size on PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted, Occupier) == 0x000000, "Member 'PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted::Occupier' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted, Patrol) == 0x000008, "Member 'PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted::Patrol' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted, bInterrupted) == 0x000010, "Member 'PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted::bInterrupted' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.ClearOverrideCompanionChatterSet
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_ClearOverrideCompanionChatterSet final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_ClearOverrideCompanionChatterSet) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_ClearOverrideCompanionChatterSet");
static_assert(sizeof(PhxAIBlueprintLibrary_ClearOverrideCompanionChatterSet) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_ClearOverrideCompanionChatterSet");
static_assert(offsetof(PhxAIBlueprintLibrary_ClearOverrideCompanionChatterSet, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_ClearOverrideCompanionChatterSet::Character' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.ClearOverrideCompanionFidgetSet
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_ClearOverrideCompanionFidgetSet final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_ClearOverrideCompanionFidgetSet) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_ClearOverrideCompanionFidgetSet");
static_assert(sizeof(PhxAIBlueprintLibrary_ClearOverrideCompanionFidgetSet) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_ClearOverrideCompanionFidgetSet");
static_assert(offsetof(PhxAIBlueprintLibrary_ClearOverrideCompanionFidgetSet, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_ClearOverrideCompanionFidgetSet::Character' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.ClearWalkWithPlayer
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_ClearWalkWithPlayer final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_ClearWalkWithPlayer) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_ClearWalkWithPlayer");
static_assert(sizeof(PhxAIBlueprintLibrary_ClearWalkWithPlayer) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_ClearWalkWithPlayer");
static_assert(offsetof(PhxAIBlueprintLibrary_ClearWalkWithPlayer, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_ClearWalkWithPlayer::Character' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.DoAttackScriptedAction
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintLibrary_DoAttackScriptedAction final
{
public:
	struct FGameplayTag                           AttackActionTag;                                   // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Target;                                            // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_DoAttackScriptedAction) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_DoAttackScriptedAction");
static_assert(sizeof(PhxAIBlueprintLibrary_DoAttackScriptedAction) == 0x000018, "Wrong size on PhxAIBlueprintLibrary_DoAttackScriptedAction");
static_assert(offsetof(PhxAIBlueprintLibrary_DoAttackScriptedAction, AttackActionTag) == 0x000000, "Member 'PhxAIBlueprintLibrary_DoAttackScriptedAction::AttackActionTag' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_DoAttackScriptedAction, Character) == 0x000008, "Member 'PhxAIBlueprintLibrary_DoAttackScriptedAction::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_DoAttackScriptedAction, Target) == 0x000010, "Member 'PhxAIBlueprintLibrary_DoAttackScriptedAction::Target' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.DoScriptedAction
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintLibrary_DoScriptedAction final
{
public:
	struct FGameplayTag                           ActionTag;                                         // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OptionalTarget;                                    // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_DoScriptedAction) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_DoScriptedAction");
static_assert(sizeof(PhxAIBlueprintLibrary_DoScriptedAction) == 0x000018, "Wrong size on PhxAIBlueprintLibrary_DoScriptedAction");
static_assert(offsetof(PhxAIBlueprintLibrary_DoScriptedAction, ActionTag) == 0x000000, "Member 'PhxAIBlueprintLibrary_DoScriptedAction::ActionTag' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_DoScriptedAction, Character) == 0x000008, "Member 'PhxAIBlueprintLibrary_DoScriptedAction::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_DoScriptedAction, OptionalTarget) == 0x000010, "Member 'PhxAIBlueprintLibrary_DoScriptedAction::OptionalTarget' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.FindNearestAliveAI
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_FindNearestAliveAI final
{
public:
	class AActor*                                 Source;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_FindNearestAliveAI) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_FindNearestAliveAI");
static_assert(sizeof(PhxAIBlueprintLibrary_FindNearestAliveAI) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_FindNearestAliveAI");
static_assert(offsetof(PhxAIBlueprintLibrary_FindNearestAliveAI, Source) == 0x000000, "Member 'PhxAIBlueprintLibrary_FindNearestAliveAI::Source' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_FindNearestAliveAI, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintLibrary_FindNearestAliveAI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.FindNearestAliveAIToPlayer
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer");
static_assert(sizeof(PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer");
static_assert(offsetof(PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer, WorldContext) == 0x000000, "Member 'PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.FollowPlayer
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintLibrary_FollowPlayer final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxAICompanionFollowDefinition*  FollowDefinition;                                  // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxAICompanionWaitDefinition*    WaitDefinition;                                    // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_FollowPlayer) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_FollowPlayer");
static_assert(sizeof(PhxAIBlueprintLibrary_FollowPlayer) == 0x000018, "Wrong size on PhxAIBlueprintLibrary_FollowPlayer");
static_assert(offsetof(PhxAIBlueprintLibrary_FollowPlayer, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_FollowPlayer::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_FollowPlayer, FollowDefinition) == 0x000008, "Member 'PhxAIBlueprintLibrary_FollowPlayer::FollowDefinition' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_FollowPlayer, WaitDefinition) == 0x000010, "Member 'PhxAIBlueprintLibrary_FollowPlayer::WaitDefinition' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.ForceWalkWithPlayer
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_ForceWalkWithPlayer final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_ForceWalkWithPlayer) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_ForceWalkWithPlayer");
static_assert(sizeof(PhxAIBlueprintLibrary_ForceWalkWithPlayer) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_ForceWalkWithPlayer");
static_assert(offsetof(PhxAIBlueprintLibrary_ForceWalkWithPlayer, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_ForceWalkWithPlayer::Character' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.GetActiveCompanion
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_GetActiveCompanion final
{
public:
	class APhxAICharacter*                        ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_GetActiveCompanion) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_GetActiveCompanion");
static_assert(sizeof(PhxAIBlueprintLibrary_GetActiveCompanion) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_GetActiveCompanion");
static_assert(offsetof(PhxAIBlueprintLibrary_GetActiveCompanion, ReturnValue) == 0x000000, "Member 'PhxAIBlueprintLibrary_GetActiveCompanion::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.GetAIGameStateManager
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_GetAIGameStateManager final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIGameStateManager*                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_GetAIGameStateManager) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_GetAIGameStateManager");
static_assert(sizeof(PhxAIBlueprintLibrary_GetAIGameStateManager) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_GetAIGameStateManager");
static_assert(offsetof(PhxAIBlueprintLibrary_GetAIGameStateManager, WorldContext) == 0x000000, "Member 'PhxAIBlueprintLibrary_GetAIGameStateManager::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetAIGameStateManager, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintLibrary_GetAIGameStateManager::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.GetAIOffensiveActionsComponent
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent final
{
public:
	class APhxAICharacterController*              AIController;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIOffensiveActionsComponent*        ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent");
static_assert(sizeof(PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent");
static_assert(offsetof(PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent, AIController) == 0x000000, "Member 'PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent::AIController' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.GetAwarenessLevelOfActor
// 0x0020 (0x0020 - 0x0000)
struct PhxAIBlueprintLibrary_GetAwarenessLevelOfActor final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Actor;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 TestActor;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIAwarenessLevel                          ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintLibrary_GetAwarenessLevelOfActor) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_GetAwarenessLevelOfActor");
static_assert(sizeof(PhxAIBlueprintLibrary_GetAwarenessLevelOfActor) == 0x000020, "Wrong size on PhxAIBlueprintLibrary_GetAwarenessLevelOfActor");
static_assert(offsetof(PhxAIBlueprintLibrary_GetAwarenessLevelOfActor, WorldContext) == 0x000000, "Member 'PhxAIBlueprintLibrary_GetAwarenessLevelOfActor::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetAwarenessLevelOfActor, Actor) == 0x000008, "Member 'PhxAIBlueprintLibrary_GetAwarenessLevelOfActor::Actor' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetAwarenessLevelOfActor, TestActor) == 0x000010, "Member 'PhxAIBlueprintLibrary_GetAwarenessLevelOfActor::TestActor' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetAwarenessLevelOfActor, ReturnValue) == 0x000018, "Member 'PhxAIBlueprintLibrary_GetAwarenessLevelOfActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.GetLastKnowLocationOfActor
// 0x0028 (0x0028 - 0x0000)
struct PhxAIBlueprintLibrary_GetLastKnowLocationOfActor final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Actor;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 TestActor;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x0018(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintLibrary_GetLastKnowLocationOfActor) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_GetLastKnowLocationOfActor");
static_assert(sizeof(PhxAIBlueprintLibrary_GetLastKnowLocationOfActor) == 0x000028, "Wrong size on PhxAIBlueprintLibrary_GetLastKnowLocationOfActor");
static_assert(offsetof(PhxAIBlueprintLibrary_GetLastKnowLocationOfActor, WorldContext) == 0x000000, "Member 'PhxAIBlueprintLibrary_GetLastKnowLocationOfActor::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetLastKnowLocationOfActor, Actor) == 0x000008, "Member 'PhxAIBlueprintLibrary_GetLastKnowLocationOfActor::Actor' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetLastKnowLocationOfActor, TestActor) == 0x000010, "Member 'PhxAIBlueprintLibrary_GetLastKnowLocationOfActor::TestActor' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetLastKnowLocationOfActor, ReturnValue) == 0x000018, "Member 'PhxAIBlueprintLibrary_GetLastKnowLocationOfActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.GetPhxAICharacterController
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_GetPhxAICharacterController final
{
public:
	class AActor*                                 ControlledActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacterController*              ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_GetPhxAICharacterController) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_GetPhxAICharacterController");
static_assert(sizeof(PhxAIBlueprintLibrary_GetPhxAICharacterController) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_GetPhxAICharacterController");
static_assert(offsetof(PhxAIBlueprintLibrary_GetPhxAICharacterController, ControlledActor) == 0x000000, "Member 'PhxAIBlueprintLibrary_GetPhxAICharacterController::ControlledActor' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetPhxAICharacterController, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintLibrary_GetPhxAICharacterController::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.GetPlayerFocusTarget
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_GetPlayerFocusTarget final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_GetPlayerFocusTarget) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_GetPlayerFocusTarget");
static_assert(sizeof(PhxAIBlueprintLibrary_GetPlayerFocusTarget) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_GetPlayerFocusTarget");
static_assert(offsetof(PhxAIBlueprintLibrary_GetPlayerFocusTarget, WorldContext) == 0x000000, "Member 'PhxAIBlueprintLibrary_GetPlayerFocusTarget::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetPlayerFocusTarget, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintLibrary_GetPlayerFocusTarget::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.GetSelectedTargetActor
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_GetSelectedTargetActor final
{
public:
	class APhxAICharacterController*              AIController;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_GetSelectedTargetActor) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_GetSelectedTargetActor");
static_assert(sizeof(PhxAIBlueprintLibrary_GetSelectedTargetActor) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_GetSelectedTargetActor");
static_assert(offsetof(PhxAIBlueprintLibrary_GetSelectedTargetActor, AIController) == 0x000000, "Member 'PhxAIBlueprintLibrary_GetSelectedTargetActor::AIController' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetSelectedTargetActor, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintLibrary_GetSelectedTargetActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.GetTimeAsPlayerFocusTarget
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget");
static_assert(sizeof(PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget");
static_assert(offsetof(PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget, WorldContext) == 0x000000, "Member 'PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget, ReturnValue) == 0x000008, "Member 'PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.IsVisibleToPlayer
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintLibrary_IsVisibleToPlayer final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Actor;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintLibrary_IsVisibleToPlayer) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_IsVisibleToPlayer");
static_assert(sizeof(PhxAIBlueprintLibrary_IsVisibleToPlayer) == 0x000018, "Wrong size on PhxAIBlueprintLibrary_IsVisibleToPlayer");
static_assert(offsetof(PhxAIBlueprintLibrary_IsVisibleToPlayer, WorldContext) == 0x000000, "Member 'PhxAIBlueprintLibrary_IsVisibleToPlayer::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_IsVisibleToPlayer, Actor) == 0x000008, "Member 'PhxAIBlueprintLibrary_IsVisibleToPlayer::Actor' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_IsVisibleToPlayer, ReturnValue) == 0x000010, "Member 'PhxAIBlueprintLibrary_IsVisibleToPlayer::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.LoadAI
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_LoadAI final
{
public:
	class APhxAISpawner_Character*                Spawner;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForceLoad;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintLibrary_LoadAI) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_LoadAI");
static_assert(sizeof(PhxAIBlueprintLibrary_LoadAI) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_LoadAI");
static_assert(offsetof(PhxAIBlueprintLibrary_LoadAI, Spawner) == 0x000000, "Member 'PhxAIBlueprintLibrary_LoadAI::Spawner' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_LoadAI, bForceLoad) == 0x000008, "Member 'PhxAIBlueprintLibrary_LoadAI::bForceLoad' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.LoadAIFromComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_LoadAIFromComponent final
{
public:
	class UPhxAISpawnerComponent_Character*       SpawnerComponent;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_LoadAIFromComponent) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_LoadAIFromComponent");
static_assert(sizeof(PhxAIBlueprintLibrary_LoadAIFromComponent) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_LoadAIFromComponent");
static_assert(offsetof(PhxAIBlueprintLibrary_LoadAIFromComponent, SpawnerComponent) == 0x000000, "Member 'PhxAIBlueprintLibrary_LoadAIFromComponent::SpawnerComponent' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.LoadAIFromEncounterGroup
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_LoadAIFromEncounterGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_LoadAIFromEncounterGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_LoadAIFromEncounterGroup");
static_assert(sizeof(PhxAIBlueprintLibrary_LoadAIFromEncounterGroup) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_LoadAIFromEncounterGroup");
static_assert(offsetof(PhxAIBlueprintLibrary_LoadAIFromEncounterGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintLibrary_LoadAIFromEncounterGroup::EncounterGroup' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.MakeAIAwareOfPlayer
// 0x0018 (0x0018 - 0x0000)
struct PhxAIBlueprintLibrary_MakeAIAwareOfPlayer final
{
public:
	class UObject*                                WorldContext;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Actor;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIAwarenessLevel                          AwarenessLevel;                                    // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintLibrary_MakeAIAwareOfPlayer) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_MakeAIAwareOfPlayer");
static_assert(sizeof(PhxAIBlueprintLibrary_MakeAIAwareOfPlayer) == 0x000018, "Wrong size on PhxAIBlueprintLibrary_MakeAIAwareOfPlayer");
static_assert(offsetof(PhxAIBlueprintLibrary_MakeAIAwareOfPlayer, WorldContext) == 0x000000, "Member 'PhxAIBlueprintLibrary_MakeAIAwareOfPlayer::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_MakeAIAwareOfPlayer, Actor) == 0x000008, "Member 'PhxAIBlueprintLibrary_MakeAIAwareOfPlayer::Actor' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_MakeAIAwareOfPlayer, AwarenessLevel) == 0x000010, "Member 'PhxAIBlueprintLibrary_MakeAIAwareOfPlayer::AwarenessLevel' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.PerformIdle
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_PerformIdle final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_PerformIdle) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_PerformIdle");
static_assert(sizeof(PhxAIBlueprintLibrary_PerformIdle) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_PerformIdle");
static_assert(offsetof(PhxAIBlueprintLibrary_PerformIdle, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_PerformIdle::Character' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.SetOverrideCompanionChatterSet
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxAICompanionChatterSetDefinition* ChatterSet;                                     // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet");
static_assert(sizeof(PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet");
static_assert(offsetof(PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet, ChatterSet) == 0x000008, "Member 'PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet::ChatterSet' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.SetOverrideCompanionFidgetSet
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxAICompanionFidgetSetDefinition* FidgetSet;                                       // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet");
static_assert(sizeof(PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet");
static_assert(offsetof(PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet, FidgetSet) == 0x000008, "Member 'PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet::FidgetSet' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.SetScriptingMode
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_SetScriptingMode final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIScriptingMode                           ScriptingMode;                                     // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIBlueprintLibrary_SetScriptingMode) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_SetScriptingMode");
static_assert(sizeof(PhxAIBlueprintLibrary_SetScriptingMode) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_SetScriptingMode");
static_assert(offsetof(PhxAIBlueprintLibrary_SetScriptingMode, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_SetScriptingMode::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_SetScriptingMode, ScriptingMode) == 0x000008, "Member 'PhxAIBlueprintLibrary_SetScriptingMode::ScriptingMode' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.StartCompanionScriptedChatter
// 0x0010 (0x0010 - 0x0000)
struct PhxAIBlueprintLibrary_StartCompanionScriptedChatter final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxAICompanionScriptedChatterDefinition* ScriptedChatter;                           // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_StartCompanionScriptedChatter) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_StartCompanionScriptedChatter");
static_assert(sizeof(PhxAIBlueprintLibrary_StartCompanionScriptedChatter) == 0x000010, "Wrong size on PhxAIBlueprintLibrary_StartCompanionScriptedChatter");
static_assert(offsetof(PhxAIBlueprintLibrary_StartCompanionScriptedChatter, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_StartCompanionScriptedChatter::Character' has a wrong offset!");
static_assert(offsetof(PhxAIBlueprintLibrary_StartCompanionScriptedChatter, ScriptedChatter) == 0x000008, "Member 'PhxAIBlueprintLibrary_StartCompanionScriptedChatter::ScriptedChatter' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.StopCompanionScriptedChatter
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_StopCompanionScriptedChatter final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_StopCompanionScriptedChatter) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_StopCompanionScriptedChatter");
static_assert(sizeof(PhxAIBlueprintLibrary_StopCompanionScriptedChatter) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_StopCompanionScriptedChatter");
static_assert(offsetof(PhxAIBlueprintLibrary_StopCompanionScriptedChatter, Character) == 0x000000, "Member 'PhxAIBlueprintLibrary_StopCompanionScriptedChatter::Character' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.UnloadAI
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_UnloadAI final
{
public:
	class APhxAISpawner_Character*                Spawner;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_UnloadAI) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_UnloadAI");
static_assert(sizeof(PhxAIBlueprintLibrary_UnloadAI) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_UnloadAI");
static_assert(offsetof(PhxAIBlueprintLibrary_UnloadAI, Spawner) == 0x000000, "Member 'PhxAIBlueprintLibrary_UnloadAI::Spawner' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.UnloadAIFromComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_UnloadAIFromComponent final
{
public:
	class UPhxAISpawnerComponent_Character*       SpawnerComponent;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_UnloadAIFromComponent) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_UnloadAIFromComponent");
static_assert(sizeof(PhxAIBlueprintLibrary_UnloadAIFromComponent) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_UnloadAIFromComponent");
static_assert(offsetof(PhxAIBlueprintLibrary_UnloadAIFromComponent, SpawnerComponent) == 0x000000, "Member 'PhxAIBlueprintLibrary_UnloadAIFromComponent::SpawnerComponent' has a wrong offset!");

// Function Phoenix.PhxAIBlueprintLibrary.UnloadAIFromEncounterGroup
// 0x0008 (0x0008 - 0x0000)
struct PhxAIBlueprintLibrary_UnloadAIFromEncounterGroup final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIBlueprintLibrary_UnloadAIFromEncounterGroup) == 0x000008, "Wrong alignment on PhxAIBlueprintLibrary_UnloadAIFromEncounterGroup");
static_assert(sizeof(PhxAIBlueprintLibrary_UnloadAIFromEncounterGroup) == 0x000008, "Wrong size on PhxAIBlueprintLibrary_UnloadAIFromEncounterGroup");
static_assert(offsetof(PhxAIBlueprintLibrary_UnloadAIFromEncounterGroup, EncounterGroup) == 0x000000, "Member 'PhxAIBlueprintLibrary_UnloadAIFromEncounterGroup::EncounterGroup' has a wrong offset!");

// Function Phoenix.PhxBloodSpatterComponent.CleanBloodOnCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxBloodSpatterComponent_CleanBloodOnCharacter final
{
public:
	float                                         AmountPerSecond;                                   // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForce;                                            // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxBloodSpatterComponent_CleanBloodOnCharacter) == 0x000004, "Wrong alignment on PhxBloodSpatterComponent_CleanBloodOnCharacter");
static_assert(sizeof(PhxBloodSpatterComponent_CleanBloodOnCharacter) == 0x000008, "Wrong size on PhxBloodSpatterComponent_CleanBloodOnCharacter");
static_assert(offsetof(PhxBloodSpatterComponent_CleanBloodOnCharacter, AmountPerSecond) == 0x000000, "Member 'PhxBloodSpatterComponent_CleanBloodOnCharacter::AmountPerSecond' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterComponent_CleanBloodOnCharacter, bForce) == 0x000004, "Member 'PhxBloodSpatterComponent_CleanBloodOnCharacter::bForce' has a wrong offset!");

// Function Phoenix.PhxBloodSpatterComponent.ProcessImpactInBloodZone
// 0x0001 (0x0001 - 0x0000)
struct PhxBloodSpatterComponent_ProcessImpactInBloodZone final
{
public:
	EBloodZoneID                                  BloodZoneId;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBloodSpatterComponent_ProcessImpactInBloodZone) == 0x000001, "Wrong alignment on PhxBloodSpatterComponent_ProcessImpactInBloodZone");
static_assert(sizeof(PhxBloodSpatterComponent_ProcessImpactInBloodZone) == 0x000001, "Wrong size on PhxBloodSpatterComponent_ProcessImpactInBloodZone");
static_assert(offsetof(PhxBloodSpatterComponent_ProcessImpactInBloodZone, BloodZoneId) == 0x000000, "Member 'PhxBloodSpatterComponent_ProcessImpactInBloodZone::BloodZoneId' has a wrong offset!");

// Function Phoenix.PhxBloodSpatterComponent.SpawnSpatterDecals
// 0x0050 (0x0050 - 0x0000)
struct PhxBloodSpatterComponent_SpawnSpatterDecals final
{
public:
	EUntaggedWoundType                            DamageType;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                HitLocation;                                       // 0x0004(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ImpactNormal;                                      // 0x0010(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                Direction;                                         // 0x001C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxBodyPartType                              BodyPart;                                          // 0x0028(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x3];                                       // 0x0029(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                MotionDirection;                                   // 0x002C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bChunkDecalsAllowed;                               // 0x0038(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class USceneComponent*                        HitComponent;                                      // 0x0040(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   SocketName;                                        // 0x0048(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBloodSpatterComponent_SpawnSpatterDecals) == 0x000008, "Wrong alignment on PhxBloodSpatterComponent_SpawnSpatterDecals");
static_assert(sizeof(PhxBloodSpatterComponent_SpawnSpatterDecals) == 0x000050, "Wrong size on PhxBloodSpatterComponent_SpawnSpatterDecals");
static_assert(offsetof(PhxBloodSpatterComponent_SpawnSpatterDecals, DamageType) == 0x000000, "Member 'PhxBloodSpatterComponent_SpawnSpatterDecals::DamageType' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterComponent_SpawnSpatterDecals, HitLocation) == 0x000004, "Member 'PhxBloodSpatterComponent_SpawnSpatterDecals::HitLocation' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterComponent_SpawnSpatterDecals, ImpactNormal) == 0x000010, "Member 'PhxBloodSpatterComponent_SpawnSpatterDecals::ImpactNormal' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterComponent_SpawnSpatterDecals, Direction) == 0x00001C, "Member 'PhxBloodSpatterComponent_SpawnSpatterDecals::Direction' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterComponent_SpawnSpatterDecals, BodyPart) == 0x000028, "Member 'PhxBloodSpatterComponent_SpawnSpatterDecals::BodyPart' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterComponent_SpawnSpatterDecals, MotionDirection) == 0x00002C, "Member 'PhxBloodSpatterComponent_SpawnSpatterDecals::MotionDirection' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterComponent_SpawnSpatterDecals, bChunkDecalsAllowed) == 0x000038, "Member 'PhxBloodSpatterComponent_SpawnSpatterDecals::bChunkDecalsAllowed' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterComponent_SpawnSpatterDecals, HitComponent) == 0x000040, "Member 'PhxBloodSpatterComponent_SpawnSpatterDecals::HitComponent' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterComponent_SpawnSpatterDecals, SocketName) == 0x000048, "Member 'PhxBloodSpatterComponent_SpawnSpatterDecals::SocketName' has a wrong offset!");

// Function Phoenix.PhxAICharacterAwarenessComponent_NPC.HandleSelectedTargetDestroyed
// 0x0008 (0x0008 - 0x0000)
struct PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDestroyed final
{
public:
	class AActor*                                 DestroyedActor;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDestroyed) == 0x000008, "Wrong alignment on PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDestroyed");
static_assert(sizeof(PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDestroyed) == 0x000008, "Wrong size on PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDestroyed");
static_assert(offsetof(PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDestroyed, DestroyedActor) == 0x000000, "Member 'PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDestroyed::DestroyedActor' has a wrong offset!");

// Function Phoenix.PhxAICharacterAwarenessComponent_NPC.HandleSelectedTargetDied
// 0x0020 (0x0020 - 0x0000)
struct PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied final
{
public:
	class UPhxHealthComponent*                    HealthComp;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied) == 0x000008, "Wrong alignment on PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied");
static_assert(sizeof(PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied) == 0x000020, "Wrong size on PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied");
static_assert(offsetof(PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied, HealthComp) == 0x000000, "Member 'PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied::HealthComp' has a wrong offset!");
static_assert(offsetof(PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied, DamageType) == 0x000008, "Member 'PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied, InstigatedBy) == 0x000010, "Member 'PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied, DamageCauser) == 0x000018, "Member 'PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxAICharacterComponent_Mahler.IsInFinalState
// 0x0001 (0x0001 - 0x0000)
struct PhxAICharacterComponent_Mahler_IsInFinalState final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterComponent_Mahler_IsInFinalState) == 0x000001, "Wrong alignment on PhxAICharacterComponent_Mahler_IsInFinalState");
static_assert(sizeof(PhxAICharacterComponent_Mahler_IsInFinalState) == 0x000001, "Wrong size on PhxAICharacterComponent_Mahler_IsInFinalState");
static_assert(offsetof(PhxAICharacterComponent_Mahler_IsInFinalState, ReturnValue) == 0x000000, "Member 'PhxAICharacterComponent_Mahler_IsInFinalState::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacterComponent_Mahler.TryTeleport
// 0x0018 (0x0018 - 0x0000)
struct PhxAICharacterComponent_Mahler_TryTeleport final
{
public:
	struct FPhxAITeleportRequest                  TeleportRequest;                                   // 0x0000(0x0014)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0014(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15[0x3];                                       // 0x0015(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAICharacterComponent_Mahler_TryTeleport) == 0x000004, "Wrong alignment on PhxAICharacterComponent_Mahler_TryTeleport");
static_assert(sizeof(PhxAICharacterComponent_Mahler_TryTeleport) == 0x000018, "Wrong size on PhxAICharacterComponent_Mahler_TryTeleport");
static_assert(offsetof(PhxAICharacterComponent_Mahler_TryTeleport, TeleportRequest) == 0x000000, "Member 'PhxAICharacterComponent_Mahler_TryTeleport::TeleportRequest' has a wrong offset!");
static_assert(offsetof(PhxAICharacterComponent_Mahler_TryTeleport, ReturnValue) == 0x000014, "Member 'PhxAICharacterComponent_Mahler_TryTeleport::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacterController.HandleAIDied
// 0x0020 (0x0020 - 0x0000)
struct PhxAICharacterController_HandleAIDied final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAICharacterController_HandleAIDied) == 0x000008, "Wrong alignment on PhxAICharacterController_HandleAIDied");
static_assert(sizeof(PhxAICharacterController_HandleAIDied) == 0x000020, "Wrong size on PhxAICharacterController_HandleAIDied");
static_assert(offsetof(PhxAICharacterController_HandleAIDied, DeadCharacter) == 0x000000, "Member 'PhxAICharacterController_HandleAIDied::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAICharacterController_HandleAIDied, KillerActor) == 0x000008, "Member 'PhxAICharacterController_HandleAIDied::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAICharacterController_HandleAIDied, KillerController) == 0x000010, "Member 'PhxAICharacterController_HandleAIDied::KillerController' has a wrong offset!");
static_assert(offsetof(PhxAICharacterController_HandleAIDied, KillingBlowHealthDelta) == 0x000018, "Member 'PhxAICharacterController_HandleAIDied::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxAICharacterController.HandleOccupiedEncounterNetworkDestroyed
// 0x0008 (0x0008 - 0x0000)
struct PhxAICharacterController_HandleOccupiedEncounterNetworkDestroyed final
{
public:
	class AActor*                                 DestroyedActor;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterController_HandleOccupiedEncounterNetworkDestroyed) == 0x000008, "Wrong alignment on PhxAICharacterController_HandleOccupiedEncounterNetworkDestroyed");
static_assert(sizeof(PhxAICharacterController_HandleOccupiedEncounterNetworkDestroyed) == 0x000008, "Wrong size on PhxAICharacterController_HandleOccupiedEncounterNetworkDestroyed");
static_assert(offsetof(PhxAICharacterController_HandleOccupiedEncounterNetworkDestroyed, DestroyedActor) == 0x000000, "Member 'PhxAICharacterController_HandleOccupiedEncounterNetworkDestroyed::DestroyedActor' has a wrong offset!");

// Function Phoenix.PhxAICharacterController.HandleOccupiedEncounterNetworkEndPlay
// 0x0010 (0x0010 - 0x0000)
struct PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay final
{
public:
	class AActor*                                 Actor;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEndPlayReason                                EndPlayReason;                                     // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay) == 0x000008, "Wrong alignment on PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay");
static_assert(sizeof(PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay) == 0x000010, "Wrong size on PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay");
static_assert(offsetof(PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay, Actor) == 0x000000, "Member 'PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay::Actor' has a wrong offset!");
static_assert(offsetof(PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay, EndPlayReason) == 0x000008, "Member 'PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay::EndPlayReason' has a wrong offset!");

// Function Phoenix.PhxAICharacterController.TickBehavior
// 0x0004 (0x0004 - 0x0000)
struct PhxAICharacterController_TickBehavior final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterController_TickBehavior) == 0x000004, "Wrong alignment on PhxAICharacterController_TickBehavior");
static_assert(sizeof(PhxAICharacterController_TickBehavior) == 0x000004, "Wrong size on PhxAICharacterController_TickBehavior");
static_assert(offsetof(PhxAICharacterController_TickBehavior, DeltaTime) == 0x000000, "Member 'PhxAICharacterController_TickBehavior::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxAICharacterController.GetCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxAICharacterController_GetCharacter final
{
public:
	class APhxAICharacter*                        ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterController_GetCharacter) == 0x000008, "Wrong alignment on PhxAICharacterController_GetCharacter");
static_assert(sizeof(PhxAICharacterController_GetCharacter) == 0x000008, "Wrong size on PhxAICharacterController_GetCharacter");
static_assert(offsetof(PhxAICharacterController_GetCharacter, ReturnValue) == 0x000000, "Member 'PhxAICharacterController_GetCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICharacterController.GetHighestPriorityEnemy
// 0x0010 (0x0010 - 0x0000)
struct PhxAICharacterController_GetHighestPriorityEnemy final
{
public:
	float                                         OutThreatScore;                                    // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class AActor*                                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICharacterController_GetHighestPriorityEnemy) == 0x000008, "Wrong alignment on PhxAICharacterController_GetHighestPriorityEnemy");
static_assert(sizeof(PhxAICharacterController_GetHighestPriorityEnemy) == 0x000010, "Wrong size on PhxAICharacterController_GetHighestPriorityEnemy");
static_assert(offsetof(PhxAICharacterController_GetHighestPriorityEnemy, OutThreatScore) == 0x000000, "Member 'PhxAICharacterController_GetHighestPriorityEnemy::OutThreatScore' has a wrong offset!");
static_assert(offsetof(PhxAICharacterController_GetHighestPriorityEnemy, ReturnValue) == 0x000008, "Member 'PhxAICharacterController_GetHighestPriorityEnemy::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSimpleMovingPlatformBase.GetPlatformFinishTransform
// 0x0030 (0x0030 - 0x0000)
struct PhxSimpleMovingPlatformBase_GetPlatformFinishTransform final
{
public:
	struct FTransform                             ReturnValue;                                       // 0x0000(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSimpleMovingPlatformBase_GetPlatformFinishTransform) == 0x000010, "Wrong alignment on PhxSimpleMovingPlatformBase_GetPlatformFinishTransform");
static_assert(sizeof(PhxSimpleMovingPlatformBase_GetPlatformFinishTransform) == 0x000030, "Wrong size on PhxSimpleMovingPlatformBase_GetPlatformFinishTransform");
static_assert(offsetof(PhxSimpleMovingPlatformBase_GetPlatformFinishTransform, ReturnValue) == 0x000000, "Member 'PhxSimpleMovingPlatformBase_GetPlatformFinishTransform::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSimpleMovingPlatformBase.GetPlatformStartTransform
// 0x0030 (0x0030 - 0x0000)
struct PhxSimpleMovingPlatformBase_GetPlatformStartTransform final
{
public:
	struct FTransform                             ReturnValue;                                       // 0x0000(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSimpleMovingPlatformBase_GetPlatformStartTransform) == 0x000010, "Wrong alignment on PhxSimpleMovingPlatformBase_GetPlatformStartTransform");
static_assert(sizeof(PhxSimpleMovingPlatformBase_GetPlatformStartTransform) == 0x000030, "Wrong size on PhxSimpleMovingPlatformBase_GetPlatformStartTransform");
static_assert(offsetof(PhxSimpleMovingPlatformBase_GetPlatformStartTransform, ReturnValue) == 0x000000, "Member 'PhxSimpleMovingPlatformBase_GetPlatformStartTransform::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxElevatorBase.IsElevatorOnBottomFloor
// 0x0001 (0x0001 - 0x0000)
struct PhxElevatorBase_IsElevatorOnBottomFloor final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxElevatorBase_IsElevatorOnBottomFloor) == 0x000001, "Wrong alignment on PhxElevatorBase_IsElevatorOnBottomFloor");
static_assert(sizeof(PhxElevatorBase_IsElevatorOnBottomFloor) == 0x000001, "Wrong size on PhxElevatorBase_IsElevatorOnBottomFloor");
static_assert(offsetof(PhxElevatorBase_IsElevatorOnBottomFloor, ReturnValue) == 0x000000, "Member 'PhxElevatorBase_IsElevatorOnBottomFloor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxElevatorBase.IsElevatorOnTopFloor
// 0x0001 (0x0001 - 0x0000)
struct PhxElevatorBase_IsElevatorOnTopFloor final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxElevatorBase_IsElevatorOnTopFloor) == 0x000001, "Wrong alignment on PhxElevatorBase_IsElevatorOnTopFloor");
static_assert(sizeof(PhxElevatorBase_IsElevatorOnTopFloor) == 0x000001, "Wrong size on PhxElevatorBase_IsElevatorOnTopFloor");
static_assert(offsetof(PhxElevatorBase_IsElevatorOnTopFloor, ReturnValue) == 0x000000, "Member 'PhxElevatorBase_IsElevatorOnTopFloor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDoorTransitionComponent.Closed
// 0x0008 (0x0008 - 0x0000)
struct PhxDoorTransitionComponent_Closed final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoorTransitionComponent_Closed) == 0x000008, "Wrong alignment on PhxDoorTransitionComponent_Closed");
static_assert(sizeof(PhxDoorTransitionComponent_Closed) == 0x000008, "Wrong size on PhxDoorTransitionComponent_Closed");
static_assert(offsetof(PhxDoorTransitionComponent_Closed, InteractedBy) == 0x000000, "Member 'PhxDoorTransitionComponent_Closed::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxDoorTransitionComponent.Opened
// 0x0008 (0x0008 - 0x0000)
struct PhxDoorTransitionComponent_Opened final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoorTransitionComponent_Opened) == 0x000008, "Wrong alignment on PhxDoorTransitionComponent_Opened");
static_assert(sizeof(PhxDoorTransitionComponent_Opened) == 0x000008, "Wrong size on PhxDoorTransitionComponent_Opened");
static_assert(offsetof(PhxDoorTransitionComponent_Opened, InteractedBy) == 0x000000, "Member 'PhxDoorTransitionComponent_Opened::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxAssetCollectionMeterManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxAssetCollectionMeterManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAssetCollectionMeterManager*        ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetCollectionMeterManager_Get) == 0x000008, "Wrong alignment on PhxAssetCollectionMeterManager_Get");
static_assert(sizeof(PhxAssetCollectionMeterManager_Get) == 0x000010, "Wrong size on PhxAssetCollectionMeterManager_Get");
static_assert(offsetof(PhxAssetCollectionMeterManager_Get, WorldContextObject) == 0x000000, "Member 'PhxAssetCollectionMeterManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAssetCollectionMeterManager_Get, ReturnValue) == 0x000008, "Member 'PhxAssetCollectionMeterManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAssetCollectionMeterManager.SetAssetCollectionMeterVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetCollectionMeterManager_SetAssetCollectionMeterVisibility final
{
public:
	ESlateVisibility                              Visibility;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetCollectionMeterManager_SetAssetCollectionMeterVisibility) == 0x000001, "Wrong alignment on PhxAssetCollectionMeterManager_SetAssetCollectionMeterVisibility");
static_assert(sizeof(PhxAssetCollectionMeterManager_SetAssetCollectionMeterVisibility) == 0x000001, "Wrong size on PhxAssetCollectionMeterManager_SetAssetCollectionMeterVisibility");
static_assert(offsetof(PhxAssetCollectionMeterManager_SetAssetCollectionMeterVisibility, Visibility) == 0x000000, "Member 'PhxAssetCollectionMeterManager_SetAssetCollectionMeterVisibility::Visibility' has a wrong offset!");

// Function Phoenix.PhxAssetCollectionMeterManager.GetIsAssetCollectionDetailsVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetCollectionMeterManager_GetIsAssetCollectionDetailsVisible final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetCollectionMeterManager_GetIsAssetCollectionDetailsVisible) == 0x000001, "Wrong alignment on PhxAssetCollectionMeterManager_GetIsAssetCollectionDetailsVisible");
static_assert(sizeof(PhxAssetCollectionMeterManager_GetIsAssetCollectionDetailsVisible) == 0x000001, "Wrong size on PhxAssetCollectionMeterManager_GetIsAssetCollectionDetailsVisible");
static_assert(offsetof(PhxAssetCollectionMeterManager_GetIsAssetCollectionDetailsVisible, ReturnValue) == 0x000000, "Member 'PhxAssetCollectionMeterManager_GetIsAssetCollectionDetailsVisible::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAssetCollectionMeterManager.GetIsAssetCollectionMeterVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetCollectionMeterManager_GetIsAssetCollectionMeterVisible final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetCollectionMeterManager_GetIsAssetCollectionMeterVisible) == 0x000001, "Wrong alignment on PhxAssetCollectionMeterManager_GetIsAssetCollectionMeterVisible");
static_assert(sizeof(PhxAssetCollectionMeterManager_GetIsAssetCollectionMeterVisible) == 0x000001, "Wrong size on PhxAssetCollectionMeterManager_GetIsAssetCollectionMeterVisible");
static_assert(offsetof(PhxAssetCollectionMeterManager_GetIsAssetCollectionMeterVisible, ReturnValue) == 0x000000, "Member 'PhxAssetCollectionMeterManager_GetIsAssetCollectionMeterVisible::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterSpace.OnBeginOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelPacingMeterSpace_OnBeginOverlap final
{
public:
	class AActor*                                 MyActor;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterSpace_OnBeginOverlap) == 0x000008, "Wrong alignment on PhxLevelPacingMeterSpace_OnBeginOverlap");
static_assert(sizeof(PhxLevelPacingMeterSpace_OnBeginOverlap) == 0x000010, "Wrong size on PhxLevelPacingMeterSpace_OnBeginOverlap");
static_assert(offsetof(PhxLevelPacingMeterSpace_OnBeginOverlap, MyActor) == 0x000000, "Member 'PhxLevelPacingMeterSpace_OnBeginOverlap::MyActor' has a wrong offset!");
static_assert(offsetof(PhxLevelPacingMeterSpace_OnBeginOverlap, OtherActor) == 0x000008, "Member 'PhxLevelPacingMeterSpace_OnBeginOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterSpace.OnEndOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelPacingMeterSpace_OnEndOverlap final
{
public:
	class AActor*                                 MyActor;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterSpace_OnEndOverlap) == 0x000008, "Wrong alignment on PhxLevelPacingMeterSpace_OnEndOverlap");
static_assert(sizeof(PhxLevelPacingMeterSpace_OnEndOverlap) == 0x000010, "Wrong size on PhxLevelPacingMeterSpace_OnEndOverlap");
static_assert(offsetof(PhxLevelPacingMeterSpace_OnEndOverlap, MyActor) == 0x000000, "Member 'PhxLevelPacingMeterSpace_OnEndOverlap::MyActor' has a wrong offset!");
static_assert(offsetof(PhxLevelPacingMeterSpace_OnEndOverlap, OtherActor) == 0x000008, "Member 'PhxLevelPacingMeterSpace_OnEndOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterSpace.SetIsActive
// 0x0001 (0x0001 - 0x0000)
struct PhxLevelPacingMeterSpace_SetIsActive final
{
public:
	bool                                          bNewActive;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterSpace_SetIsActive) == 0x000001, "Wrong alignment on PhxLevelPacingMeterSpace_SetIsActive");
static_assert(sizeof(PhxLevelPacingMeterSpace_SetIsActive) == 0x000001, "Wrong size on PhxLevelPacingMeterSpace_SetIsActive");
static_assert(offsetof(PhxLevelPacingMeterSpace_SetIsActive, bNewActive) == 0x000000, "Member 'PhxLevelPacingMeterSpace_SetIsActive::bNewActive' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterSpace.GetIsActive
// 0x0001 (0x0001 - 0x0000)
struct PhxLevelPacingMeterSpace_GetIsActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterSpace_GetIsActive) == 0x000001, "Wrong alignment on PhxLevelPacingMeterSpace_GetIsActive");
static_assert(sizeof(PhxLevelPacingMeterSpace_GetIsActive) == 0x000001, "Wrong size on PhxLevelPacingMeterSpace_GetIsActive");
static_assert(offsetof(PhxLevelPacingMeterSpace_GetIsActive, ReturnValue) == 0x000000, "Member 'PhxLevelPacingMeterSpace_GetIsActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterSpace.GetLevelSpaceType
// 0x0001 (0x0001 - 0x0000)
struct PhxLevelPacingMeterSpace_GetLevelSpaceType final
{
public:
	ELevelSpaceType                               ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterSpace_GetLevelSpaceType) == 0x000001, "Wrong alignment on PhxLevelPacingMeterSpace_GetLevelSpaceType");
static_assert(sizeof(PhxLevelPacingMeterSpace_GetLevelSpaceType) == 0x000001, "Wrong size on PhxLevelPacingMeterSpace_GetLevelSpaceType");
static_assert(offsetof(PhxLevelPacingMeterSpace_GetLevelSpaceType, ReturnValue) == 0x000000, "Member 'PhxLevelPacingMeterSpace_GetLevelSpaceType::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterSpace.GetTimeInSpace
// 0x0004 (0x0004 - 0x0000)
struct PhxLevelPacingMeterSpace_GetTimeInSpace final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterSpace_GetTimeInSpace) == 0x000004, "Wrong alignment on PhxLevelPacingMeterSpace_GetTimeInSpace");
static_assert(sizeof(PhxLevelPacingMeterSpace_GetTimeInSpace) == 0x000004, "Wrong size on PhxLevelPacingMeterSpace_GetTimeInSpace");
static_assert(offsetof(PhxLevelPacingMeterSpace_GetTimeInSpace, ReturnValue) == 0x000000, "Member 'PhxLevelPacingMeterSpace_GetTimeInSpace::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterSpace.GetUniqueID
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelPacingMeterSpace_GetUniqueID final
{
public:
	struct FGuid                                  ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterSpace_GetUniqueID) == 0x000004, "Wrong alignment on PhxLevelPacingMeterSpace_GetUniqueID");
static_assert(sizeof(PhxLevelPacingMeterSpace_GetUniqueID) == 0x000010, "Wrong size on PhxLevelPacingMeterSpace_GetUniqueID");
static_assert(offsetof(PhxLevelPacingMeterSpace_GetUniqueID, ReturnValue) == 0x000000, "Member 'PhxLevelPacingMeterSpace_GetUniqueID::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDestroyable.HandleOnOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxDestroyable_HandleOnOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDestroyable_HandleOnOverlap) == 0x000008, "Wrong alignment on PhxDestroyable_HandleOnOverlap");
static_assert(sizeof(PhxDestroyable_HandleOnOverlap) == 0x0000A8, "Wrong size on PhxDestroyable_HandleOnOverlap");
static_assert(offsetof(PhxDestroyable_HandleOnOverlap, OverlappedComponent) == 0x000000, "Member 'PhxDestroyable_HandleOnOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlap, OtherActor) == 0x000008, "Member 'PhxDestroyable_HandleOnOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlap, OtherComp) == 0x000010, "Member 'PhxDestroyable_HandleOnOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxDestroyable_HandleOnOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlap, bFromSweep) == 0x00001C, "Member 'PhxDestroyable_HandleOnOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlap, SweepResult) == 0x000020, "Member 'PhxDestroyable_HandleOnOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxDestroyable.HandleOnOverlapWithNearDestroyable
// 0x00A8 (0x00A8 - 0x0000)
struct PhxDestroyable_HandleOnOverlapWithNearDestroyable final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDestroyable_HandleOnOverlapWithNearDestroyable) == 0x000008, "Wrong alignment on PhxDestroyable_HandleOnOverlapWithNearDestroyable");
static_assert(sizeof(PhxDestroyable_HandleOnOverlapWithNearDestroyable) == 0x0000A8, "Wrong size on PhxDestroyable_HandleOnOverlapWithNearDestroyable");
static_assert(offsetof(PhxDestroyable_HandleOnOverlapWithNearDestroyable, OverlappedComponent) == 0x000000, "Member 'PhxDestroyable_HandleOnOverlapWithNearDestroyable::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlapWithNearDestroyable, OtherActor) == 0x000008, "Member 'PhxDestroyable_HandleOnOverlapWithNearDestroyable::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlapWithNearDestroyable, OtherComp) == 0x000010, "Member 'PhxDestroyable_HandleOnOverlapWithNearDestroyable::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlapWithNearDestroyable, OtherBodyIndex) == 0x000018, "Member 'PhxDestroyable_HandleOnOverlapWithNearDestroyable::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlapWithNearDestroyable, bFromSweep) == 0x00001C, "Member 'PhxDestroyable_HandleOnOverlapWithNearDestroyable::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleOnOverlapWithNearDestroyable, SweepResult) == 0x000020, "Member 'PhxDestroyable_HandleOnOverlapWithNearDestroyable::SweepResult' has a wrong offset!");

// Function Phoenix.PhxDestroyable.HandleTakeAnyDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxDestroyable_HandleTakeAnyDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDestroyable_HandleTakeAnyDamage) == 0x000008, "Wrong alignment on PhxDestroyable_HandleTakeAnyDamage");
static_assert(sizeof(PhxDestroyable_HandleTakeAnyDamage) == 0x000028, "Wrong size on PhxDestroyable_HandleTakeAnyDamage");
static_assert(offsetof(PhxDestroyable_HandleTakeAnyDamage, DamagedActor) == 0x000000, "Member 'PhxDestroyable_HandleTakeAnyDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleTakeAnyDamage, Damage) == 0x000008, "Member 'PhxDestroyable_HandleTakeAnyDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleTakeAnyDamage, DamageType) == 0x000010, "Member 'PhxDestroyable_HandleTakeAnyDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleTakeAnyDamage, InstigatedBy) == 0x000018, "Member 'PhxDestroyable_HandleTakeAnyDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_HandleTakeAnyDamage, DamageCauser) == 0x000020, "Member 'PhxDestroyable_HandleTakeAnyDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxDestroyable.OnBreakBP
// 0x0010 (0x0010 - 0x0000)
struct PhxDestroyable_OnBreakBP final
{
public:
	class AActor*                                 InBreakingActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ByOtherDestroyable;                                // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDestroyable_OnBreakBP) == 0x000008, "Wrong alignment on PhxDestroyable_OnBreakBP");
static_assert(sizeof(PhxDestroyable_OnBreakBP) == 0x000010, "Wrong size on PhxDestroyable_OnBreakBP");
static_assert(offsetof(PhxDestroyable_OnBreakBP, InBreakingActor) == 0x000000, "Member 'PhxDestroyable_OnBreakBP::InBreakingActor' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_OnBreakBP, ByOtherDestroyable) == 0x000008, "Member 'PhxDestroyable_OnBreakBP::ByOtherDestroyable' has a wrong offset!");

// Function Phoenix.PhxDestroyable.OnPartHitBP
// 0x00A8 (0x00A8 - 0x0000)
struct PhxDestroyable_OnPartHitBP final
{
public:
	struct FHitResult                             Hit;                                               // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0088(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_94[0x4];                                       // 0x0094(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPrimitiveComponent*                    HitComp;                                           // 0x0098(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x00A0(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDestroyable_OnPartHitBP) == 0x000008, "Wrong alignment on PhxDestroyable_OnPartHitBP");
static_assert(sizeof(PhxDestroyable_OnPartHitBP) == 0x0000A8, "Wrong size on PhxDestroyable_OnPartHitBP");
static_assert(offsetof(PhxDestroyable_OnPartHitBP, Hit) == 0x000000, "Member 'PhxDestroyable_OnPartHitBP::Hit' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_OnPartHitBP, NormalImpulse) == 0x000088, "Member 'PhxDestroyable_OnPartHitBP::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_OnPartHitBP, HitComp) == 0x000098, "Member 'PhxDestroyable_OnPartHitBP::HitComp' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_OnPartHitBP, OtherComp) == 0x0000A0, "Member 'PhxDestroyable_OnPartHitBP::OtherComp' has a wrong offset!");

// Function Phoenix.PhxDestroyable.OnPartHitCallback
// 0x00B0 (0x00B0 - 0x0000)
struct PhxDestroyable_OnPartHitCallback final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDestroyable_OnPartHitCallback) == 0x000008, "Wrong alignment on PhxDestroyable_OnPartHitCallback");
static_assert(sizeof(PhxDestroyable_OnPartHitCallback) == 0x0000B0, "Wrong size on PhxDestroyable_OnPartHitCallback");
static_assert(offsetof(PhxDestroyable_OnPartHitCallback, HitComp) == 0x000000, "Member 'PhxDestroyable_OnPartHitCallback::HitComp' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_OnPartHitCallback, OtherActor) == 0x000008, "Member 'PhxDestroyable_OnPartHitCallback::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_OnPartHitCallback, OtherComp) == 0x000010, "Member 'PhxDestroyable_OnPartHitCallback::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_OnPartHitCallback, NormalImpulse) == 0x000018, "Member 'PhxDestroyable_OnPartHitCallback::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_OnPartHitCallback, Hit) == 0x000024, "Member 'PhxDestroyable_OnPartHitCallback::Hit' has a wrong offset!");

// Function Phoenix.PhxDestroyable.OnPartPutToSleep
// 0x0010 (0x0010 - 0x0000)
struct PhxDestroyable_OnPartPutToSleep final
{
public:
	class UPrimitiveComponent*                    InComp;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   InBoneName;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDestroyable_OnPartPutToSleep) == 0x000008, "Wrong alignment on PhxDestroyable_OnPartPutToSleep");
static_assert(sizeof(PhxDestroyable_OnPartPutToSleep) == 0x000010, "Wrong size on PhxDestroyable_OnPartPutToSleep");
static_assert(offsetof(PhxDestroyable_OnPartPutToSleep, InComp) == 0x000000, "Member 'PhxDestroyable_OnPartPutToSleep::InComp' has a wrong offset!");
static_assert(offsetof(PhxDestroyable_OnPartPutToSleep, InBoneName) == 0x000008, "Member 'PhxDestroyable_OnPartPutToSleep::InBoneName' has a wrong offset!");

// Function Phoenix.PhxDestroyable.IsDestroyed
// 0x0001 (0x0001 - 0x0000)
struct PhxDestroyable_IsDestroyed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDestroyable_IsDestroyed) == 0x000001, "Wrong alignment on PhxDestroyable_IsDestroyed");
static_assert(sizeof(PhxDestroyable_IsDestroyed) == 0x000001, "Wrong size on PhxDestroyable_IsDestroyed");
static_assert(offsetof(PhxDestroyable_IsDestroyed, ReturnValue) == 0x000000, "Member 'PhxDestroyable_IsDestroyed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.AreScreenMessagesEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxDebugBlueprintLibrary_AreScreenMessagesEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDebugBlueprintLibrary_AreScreenMessagesEnabled) == 0x000001, "Wrong alignment on PhxDebugBlueprintLibrary_AreScreenMessagesEnabled");
static_assert(sizeof(PhxDebugBlueprintLibrary_AreScreenMessagesEnabled) == 0x000001, "Wrong size on PhxDebugBlueprintLibrary_AreScreenMessagesEnabled");
static_assert(offsetof(PhxDebugBlueprintLibrary_AreScreenMessagesEnabled, ReturnValue) == 0x000000, "Member 'PhxDebugBlueprintLibrary_AreScreenMessagesEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.DebugStartLoadingScreen
// 0x0010 (0x0010 - 0x0000)
struct PhxDebugBlueprintLibrary_DebugStartLoadingScreen final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class ULevelTransitionDataAsset*        LevelTransitionData;                               // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDebugBlueprintLibrary_DebugStartLoadingScreen) == 0x000008, "Wrong alignment on PhxDebugBlueprintLibrary_DebugStartLoadingScreen");
static_assert(sizeof(PhxDebugBlueprintLibrary_DebugStartLoadingScreen) == 0x000010, "Wrong size on PhxDebugBlueprintLibrary_DebugStartLoadingScreen");
static_assert(offsetof(PhxDebugBlueprintLibrary_DebugStartLoadingScreen, WorldContextObject) == 0x000000, "Member 'PhxDebugBlueprintLibrary_DebugStartLoadingScreen::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_DebugStartLoadingScreen, LevelTransitionData) == 0x000008, "Member 'PhxDebugBlueprintLibrary_DebugStartLoadingScreen::LevelTransitionData' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.GetSimulateInEditorViewTransformWrapper
// 0x0040 (0x0040 - 0x0000)
struct PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper final
{
public:
	struct FTransform                             OutViewTransform;                                  // 0x0000(0x0030)(Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0030(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0xF];                                       // 0x0031(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper) == 0x000010, "Wrong alignment on PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper");
static_assert(sizeof(PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper) == 0x000040, "Wrong size on PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper");
static_assert(offsetof(PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper, OutViewTransform) == 0x000000, "Member 'PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper::OutViewTransform' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper, ReturnValue) == 0x000030, "Member 'PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.IsEngineShowFlagEnabled
// 0x0020 (0x0020 - 0x0000)
struct PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 FlagString;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled) == 0x000008, "Wrong alignment on PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled");
static_assert(sizeof(PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled) == 0x000020, "Wrong size on PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled, WorldContextObject) == 0x000000, "Member 'PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled, FlagString) == 0x000008, "Member 'PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled::FlagString' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled, ReturnValue) == 0x000018, "Member 'PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.IsGameplayDebuggerCategoryEnabled
// 0x0010 (0x0010 - 0x0000)
struct PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         CategoryId;                                        // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x000C(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled) == 0x000008, "Wrong alignment on PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled");
static_assert(sizeof(PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled) == 0x000010, "Wrong size on PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled, WorldContextObject) == 0x000000, "Member 'PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled, CategoryId) == 0x000008, "Member 'PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled::CategoryId' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled, ReturnValue) == 0x00000C, "Member 'PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.IsGameplayDebuggerEnabled
// 0x0010 (0x0010 - 0x0000)
struct PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled) == 0x000008, "Wrong alignment on PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled");
static_assert(sizeof(PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled) == 0x000010, "Wrong size on PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled, WorldContextObject) == 0x000000, "Member 'PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled, ReturnValue) == 0x000008, "Member 'PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.IsLevelStreamingFrozen
// 0x0010 (0x0010 - 0x0000)
struct PhxDebugBlueprintLibrary_IsLevelStreamingFrozen final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugBlueprintLibrary_IsLevelStreamingFrozen) == 0x000008, "Wrong alignment on PhxDebugBlueprintLibrary_IsLevelStreamingFrozen");
static_assert(sizeof(PhxDebugBlueprintLibrary_IsLevelStreamingFrozen) == 0x000010, "Wrong size on PhxDebugBlueprintLibrary_IsLevelStreamingFrozen");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsLevelStreamingFrozen, WorldContextObject) == 0x000000, "Member 'PhxDebugBlueprintLibrary_IsLevelStreamingFrozen::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsLevelStreamingFrozen, ReturnValue) == 0x000008, "Member 'PhxDebugBlueprintLibrary_IsLevelStreamingFrozen::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.IsRayTracingEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxDebugBlueprintLibrary_IsRayTracingEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDebugBlueprintLibrary_IsRayTracingEnabled) == 0x000001, "Wrong alignment on PhxDebugBlueprintLibrary_IsRayTracingEnabled");
static_assert(sizeof(PhxDebugBlueprintLibrary_IsRayTracingEnabled) == 0x000001, "Wrong size on PhxDebugBlueprintLibrary_IsRayTracingEnabled");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsRayTracingEnabled, ReturnValue) == 0x000000, "Member 'PhxDebugBlueprintLibrary_IsRayTracingEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.IsRenderingFrozen
// 0x0010 (0x0010 - 0x0000)
struct PhxDebugBlueprintLibrary_IsRenderingFrozen final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugBlueprintLibrary_IsRenderingFrozen) == 0x000008, "Wrong alignment on PhxDebugBlueprintLibrary_IsRenderingFrozen");
static_assert(sizeof(PhxDebugBlueprintLibrary_IsRenderingFrozen) == 0x000010, "Wrong size on PhxDebugBlueprintLibrary_IsRenderingFrozen");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsRenderingFrozen, WorldContextObject) == 0x000000, "Member 'PhxDebugBlueprintLibrary_IsRenderingFrozen::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsRenderingFrozen, ReturnValue) == 0x000008, "Member 'PhxDebugBlueprintLibrary_IsRenderingFrozen::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.IsStatEnabled
// 0x0020 (0x0020 - 0x0000)
struct PhxDebugBlueprintLibrary_IsStatEnabled final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 StatString;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugBlueprintLibrary_IsStatEnabled) == 0x000008, "Wrong alignment on PhxDebugBlueprintLibrary_IsStatEnabled");
static_assert(sizeof(PhxDebugBlueprintLibrary_IsStatEnabled) == 0x000020, "Wrong size on PhxDebugBlueprintLibrary_IsStatEnabled");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsStatEnabled, WorldContextObject) == 0x000000, "Member 'PhxDebugBlueprintLibrary_IsStatEnabled::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsStatEnabled, StatString) == 0x000008, "Member 'PhxDebugBlueprintLibrary_IsStatEnabled::StatString' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_IsStatEnabled, ReturnValue) == 0x000018, "Member 'PhxDebugBlueprintLibrary_IsStatEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugBlueprintLibrary.OutputStringToFile
// 0x0028 (0x0028 - 0x0000)
struct PhxDebugBlueprintLibrary_OutputStringToFile final
{
public:
	class FString                                 StringData;                                        // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAppend;                                           // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 FileNameWithExt;                                   // 0x0018(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDebugBlueprintLibrary_OutputStringToFile) == 0x000008, "Wrong alignment on PhxDebugBlueprintLibrary_OutputStringToFile");
static_assert(sizeof(PhxDebugBlueprintLibrary_OutputStringToFile) == 0x000028, "Wrong size on PhxDebugBlueprintLibrary_OutputStringToFile");
static_assert(offsetof(PhxDebugBlueprintLibrary_OutputStringToFile, StringData) == 0x000000, "Member 'PhxDebugBlueprintLibrary_OutputStringToFile::StringData' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_OutputStringToFile, bAppend) == 0x000010, "Member 'PhxDebugBlueprintLibrary_OutputStringToFile::bAppend' has a wrong offset!");
static_assert(offsetof(PhxDebugBlueprintLibrary_OutputStringToFile, FileNameWithExt) == 0x000018, "Member 'PhxDebugBlueprintLibrary_OutputStringToFile::FileNameWithExt' has a wrong offset!");

// Function Phoenix.PhxAIResource_Charge.OnCharacterRecievedDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxAIResource_Charge_OnCharacterRecievedDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIResource_Charge_OnCharacterRecievedDamage) == 0x000008, "Wrong alignment on PhxAIResource_Charge_OnCharacterRecievedDamage");
static_assert(sizeof(PhxAIResource_Charge_OnCharacterRecievedDamage) == 0x000028, "Wrong size on PhxAIResource_Charge_OnCharacterRecievedDamage");
static_assert(offsetof(PhxAIResource_Charge_OnCharacterRecievedDamage, DamagedActor) == 0x000000, "Member 'PhxAIResource_Charge_OnCharacterRecievedDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxAIResource_Charge_OnCharacterRecievedDamage, Damage) == 0x000008, "Member 'PhxAIResource_Charge_OnCharacterRecievedDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxAIResource_Charge_OnCharacterRecievedDamage, DamageType) == 0x000010, "Member 'PhxAIResource_Charge_OnCharacterRecievedDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAIResource_Charge_OnCharacterRecievedDamage, InstigatedBy) == 0x000018, "Member 'PhxAIResource_Charge_OnCharacterRecievedDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAIResource_Charge_OnCharacterRecievedDamage, DamageCauser) == 0x000020, "Member 'PhxAIResource_Charge_OnCharacterRecievedDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxInteractableInterface.CanInteract
// 0x0001 (0x0001 - 0x0000)
struct PhxInteractableInterface_CanInteract final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInteractableInterface_CanInteract) == 0x000001, "Wrong alignment on PhxInteractableInterface_CanInteract");
static_assert(sizeof(PhxInteractableInterface_CanInteract) == 0x000001, "Wrong size on PhxInteractableInterface_CanInteract");
static_assert(offsetof(PhxInteractableInterface_CanInteract, ReturnValue) == 0x000000, "Member 'PhxInteractableInterface_CanInteract::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputRecorder.OnInputAxis
// 0x0028 (0x0028 - 0x0000)
struct PhxInputRecorder_OnInputAxis final
{
public:
	struct FKey                                   Key;                                               // 0x0000(0x0018)(ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Delta;                                             // 0x0018(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DeltaTime;                                         // 0x001C(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumSamples;                                        // 0x0020(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxInputRecorder_OnInputAxis) == 0x000008, "Wrong alignment on PhxInputRecorder_OnInputAxis");
static_assert(sizeof(PhxInputRecorder_OnInputAxis) == 0x000028, "Wrong size on PhxInputRecorder_OnInputAxis");
static_assert(offsetof(PhxInputRecorder_OnInputAxis, Key) == 0x000000, "Member 'PhxInputRecorder_OnInputAxis::Key' has a wrong offset!");
static_assert(offsetof(PhxInputRecorder_OnInputAxis, Delta) == 0x000018, "Member 'PhxInputRecorder_OnInputAxis::Delta' has a wrong offset!");
static_assert(offsetof(PhxInputRecorder_OnInputAxis, DeltaTime) == 0x00001C, "Member 'PhxInputRecorder_OnInputAxis::DeltaTime' has a wrong offset!");
static_assert(offsetof(PhxInputRecorder_OnInputAxis, NumSamples) == 0x000020, "Member 'PhxInputRecorder_OnInputAxis::NumSamples' has a wrong offset!");

// Function Phoenix.PhxInputRecorder.OnInputKey
// 0x0020 (0x0020 - 0x0000)
struct PhxInputRecorder_OnInputKey final
{
public:
	struct FKey                                   Key;                                               // 0x0000(0x0018)(ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputEvent                                   EventType;                                         // 0x0018(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x3];                                       // 0x0019(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AmountDepressed;                                   // 0x001C(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputRecorder_OnInputKey) == 0x000008, "Wrong alignment on PhxInputRecorder_OnInputKey");
static_assert(sizeof(PhxInputRecorder_OnInputKey) == 0x000020, "Wrong size on PhxInputRecorder_OnInputKey");
static_assert(offsetof(PhxInputRecorder_OnInputKey, Key) == 0x000000, "Member 'PhxInputRecorder_OnInputKey::Key' has a wrong offset!");
static_assert(offsetof(PhxInputRecorder_OnInputKey, EventType) == 0x000018, "Member 'PhxInputRecorder_OnInputKey::EventType' has a wrong offset!");
static_assert(offsetof(PhxInputRecorder_OnInputKey, AmountDepressed) == 0x00001C, "Member 'PhxInputRecorder_OnInputKey::AmountDepressed' has a wrong offset!");

// Function Phoenix.PhxHasAnyOfEntitlements.HasAnyOfEntitlement
// 0x0018 (0x0018 - 0x0000)
struct PhxHasAnyOfEntitlements_HasAnyOfEntitlement final
{
public:
	TArray<EPhxEntitlement>                       InEntitlements;                                    // 0x0000(0x0010)(Parm, ZeroConstructor, NativeAccessSpecifierPublic)
	class UPhxHasAnyOfEntitlements*               ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasAnyOfEntitlements_HasAnyOfEntitlement) == 0x000008, "Wrong alignment on PhxHasAnyOfEntitlements_HasAnyOfEntitlement");
static_assert(sizeof(PhxHasAnyOfEntitlements_HasAnyOfEntitlement) == 0x000018, "Wrong size on PhxHasAnyOfEntitlements_HasAnyOfEntitlement");
static_assert(offsetof(PhxHasAnyOfEntitlements_HasAnyOfEntitlement, InEntitlements) == 0x000000, "Member 'PhxHasAnyOfEntitlements_HasAnyOfEntitlement::InEntitlements' has a wrong offset!");
static_assert(offsetof(PhxHasAnyOfEntitlements_HasAnyOfEntitlement, ReturnValue) == 0x000010, "Member 'PhxHasAnyOfEntitlements_HasAnyOfEntitlement::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHasAnyOfEntitlements.HandleFetchEntitlements
// 0x0050 (0x0050 - 0x0000)
struct PhxHasAnyOfEntitlements_HandleFetchEntitlements final
{
public:
	struct FPhxEntitlementOwnership               Ownership;                                         // 0x0000(0x0050)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasAnyOfEntitlements_HandleFetchEntitlements) == 0x000008, "Wrong alignment on PhxHasAnyOfEntitlements_HandleFetchEntitlements");
static_assert(sizeof(PhxHasAnyOfEntitlements_HandleFetchEntitlements) == 0x000050, "Wrong size on PhxHasAnyOfEntitlements_HandleFetchEntitlements");
static_assert(offsetof(PhxHasAnyOfEntitlements_HandleFetchEntitlements, Ownership) == 0x000000, "Member 'PhxHasAnyOfEntitlements_HandleFetchEntitlements::Ownership' has a wrong offset!");

// Function Phoenix.PhxHasAnyOfEntitlements.HandleFetchOnlineAccount
// 0x0010 (0x0010 - 0x0000)
struct PhxHasAnyOfEntitlements_HandleFetchOnlineAccount final
{
public:
	bool                                          bSuccess;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	const class USDSOnlineAccount*                OnlineAccount;                                     // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasAnyOfEntitlements_HandleFetchOnlineAccount) == 0x000008, "Wrong alignment on PhxHasAnyOfEntitlements_HandleFetchOnlineAccount");
static_assert(sizeof(PhxHasAnyOfEntitlements_HandleFetchOnlineAccount) == 0x000010, "Wrong size on PhxHasAnyOfEntitlements_HandleFetchOnlineAccount");
static_assert(offsetof(PhxHasAnyOfEntitlements_HandleFetchOnlineAccount, bSuccess) == 0x000000, "Member 'PhxHasAnyOfEntitlements_HandleFetchOnlineAccount::bSuccess' has a wrong offset!");
static_assert(offsetof(PhxHasAnyOfEntitlements_HandleFetchOnlineAccount, OnlineAccount) == 0x000008, "Member 'PhxHasAnyOfEntitlements_HandleFetchOnlineAccount::OnlineAccount' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_PlayDead.OnActorRecievedDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage");
static_assert(sizeof(PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage) == 0x000028, "Wrong size on PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage");
static_assert(offsetof(PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage, DamagedActor) == 0x000000, "Member 'PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage, Damage) == 0x000008, "Member 'PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage, DamageType) == 0x000010, "Member 'PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage, InstigatedBy) == 0x000018, "Member 'PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage, DamageCauser) == 0x000020, "Member 'PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.SplineState.GetDistanceAlongSpline
// 0x0008 (0x0008 - 0x0000)
struct SplineState_GetDistanceAlongSpline final
{
public:
	bool                                          normalized;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SplineState_GetDistanceAlongSpline) == 0x000004, "Wrong alignment on SplineState_GetDistanceAlongSpline");
static_assert(sizeof(SplineState_GetDistanceAlongSpline) == 0x000008, "Wrong size on SplineState_GetDistanceAlongSpline");
static_assert(offsetof(SplineState_GetDistanceAlongSpline, normalized) == 0x000000, "Member 'SplineState_GetDistanceAlongSpline::normalized' has a wrong offset!");
static_assert(offsetof(SplineState_GetDistanceAlongSpline, ReturnValue) == 0x000004, "Member 'SplineState_GetDistanceAlongSpline::ReturnValue' has a wrong offset!");

// Function Phoenix.SplineState.GetFinishingEnd
// 0x0001 (0x0001 - 0x0000)
struct SplineState_GetFinishingEnd final
{
public:
	ESplineEnd                                    ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SplineState_GetFinishingEnd) == 0x000001, "Wrong alignment on SplineState_GetFinishingEnd");
static_assert(sizeof(SplineState_GetFinishingEnd) == 0x000001, "Wrong size on SplineState_GetFinishingEnd");
static_assert(offsetof(SplineState_GetFinishingEnd, ReturnValue) == 0x000000, "Member 'SplineState_GetFinishingEnd::ReturnValue' has a wrong offset!");

// Function Phoenix.SplineMontageState.GetClampedMontagePosition
// 0x0004 (0x0004 - 0x0000)
struct SplineMontageState_GetClampedMontagePosition final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SplineMontageState_GetClampedMontagePosition) == 0x000004, "Wrong alignment on SplineMontageState_GetClampedMontagePosition");
static_assert(sizeof(SplineMontageState_GetClampedMontagePosition) == 0x000004, "Wrong size on SplineMontageState_GetClampedMontagePosition");
static_assert(offsetof(SplineMontageState_GetClampedMontagePosition, ReturnValue) == 0x000000, "Member 'SplineMontageState_GetClampedMontagePosition::ReturnValue' has a wrong offset!");

// Function Phoenix.SplineMontageState.GetCycledMontagePosition
// 0x0004 (0x0004 - 0x0000)
struct SplineMontageState_GetCycledMontagePosition final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SplineMontageState_GetCycledMontagePosition) == 0x000004, "Wrong alignment on SplineMontageState_GetCycledMontagePosition");
static_assert(sizeof(SplineMontageState_GetCycledMontagePosition) == 0x000004, "Wrong size on SplineMontageState_GetCycledMontagePosition");
static_assert(offsetof(SplineMontageState_GetCycledMontagePosition, ReturnValue) == 0x000000, "Member 'SplineMontageState_GetCycledMontagePosition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAICompanionPOIVolume.SetEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxAICompanionPOIVolume_SetEnabled final
{
public:
	bool                                          bInEnabled;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAICompanionPOIVolume_SetEnabled) == 0x000001, "Wrong alignment on PhxAICompanionPOIVolume_SetEnabled");
static_assert(sizeof(PhxAICompanionPOIVolume_SetEnabled) == 0x000001, "Wrong size on PhxAICompanionPOIVolume_SetEnabled");
static_assert(offsetof(PhxAICompanionPOIVolume_SetEnabled, bInEnabled) == 0x000000, "Member 'PhxAICompanionPOIVolume_SetEnabled::bInEnabled' has a wrong offset!");

// Function Phoenix.PhxAIDefensiveActionsComponent.SetBlockProbability
// 0x0004 (0x0004 - 0x0000)
struct PhxAIDefensiveActionsComponent_SetBlockProbability final
{
public:
	float                                         InProbability;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIDefensiveActionsComponent_SetBlockProbability) == 0x000004, "Wrong alignment on PhxAIDefensiveActionsComponent_SetBlockProbability");
static_assert(sizeof(PhxAIDefensiveActionsComponent_SetBlockProbability) == 0x000004, "Wrong size on PhxAIDefensiveActionsComponent_SetBlockProbability");
static_assert(offsetof(PhxAIDefensiveActionsComponent_SetBlockProbability, InProbability) == 0x000000, "Member 'PhxAIDefensiveActionsComponent_SetBlockProbability::InProbability' has a wrong offset!");

// Function Phoenix.PhxAIDefensiveActionsComponent.SetDodgeProbability
// 0x0004 (0x0004 - 0x0000)
struct PhxAIDefensiveActionsComponent_SetDodgeProbability final
{
public:
	float                                         InProbability;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIDefensiveActionsComponent_SetDodgeProbability) == 0x000004, "Wrong alignment on PhxAIDefensiveActionsComponent_SetDodgeProbability");
static_assert(sizeof(PhxAIDefensiveActionsComponent_SetDodgeProbability) == 0x000004, "Wrong size on PhxAIDefensiveActionsComponent_SetDodgeProbability");
static_assert(offsetof(PhxAIDefensiveActionsComponent_SetDodgeProbability, InProbability) == 0x000000, "Member 'PhxAIDefensiveActionsComponent_SetDodgeProbability::InProbability' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveDescriptor.GetTag
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroupWaveDescriptor_GetTag final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroupWaveDescriptor_GetTag) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveDescriptor_GetTag");
static_assert(sizeof(PhxAIEncounterGroupWaveDescriptor_GetTag) == 0x000010, "Wrong size on PhxAIEncounterGroupWaveDescriptor_GetTag");
static_assert(offsetof(PhxAIEncounterGroupWaveDescriptor_GetTag, ReturnValue) == 0x000000, "Member 'PhxAIEncounterGroupWaveDescriptor_GetTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_BlueprintBase.ReceiveStartPlay
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay) == 0x000010, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay, EncounterGroup) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay, ReturnValue) == 0x000008, "Member 'PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_BlueprintBase.ReceiveEvaluateCondition
// 0x0018 (0x0018 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Tag;                                               // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition) == 0x000018, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition, EncounterGroup) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition, Tag) == 0x000008, "Member 'PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition::Tag' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition, ReturnValue) == 0x000010, "Member 'PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_PPEEnemySlam.OnEnemyHit
// 0x00B0 (0x00B0 - 0x0000)
struct PhxGameplayAbility_PPEEnemySlam_OnEnemyHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayAbility_PPEEnemySlam_OnEnemyHit) == 0x000008, "Wrong alignment on PhxGameplayAbility_PPEEnemySlam_OnEnemyHit");
static_assert(sizeof(PhxGameplayAbility_PPEEnemySlam_OnEnemyHit) == 0x0000B0, "Wrong size on PhxGameplayAbility_PPEEnemySlam_OnEnemyHit");
static_assert(offsetof(PhxGameplayAbility_PPEEnemySlam_OnEnemyHit, HitComp) == 0x000000, "Member 'PhxGameplayAbility_PPEEnemySlam_OnEnemyHit::HitComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemySlam_OnEnemyHit, OtherActor) == 0x000008, "Member 'PhxGameplayAbility_PPEEnemySlam_OnEnemyHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemySlam_OnEnemyHit, OtherComp) == 0x000010, "Member 'PhxGameplayAbility_PPEEnemySlam_OnEnemyHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemySlam_OnEnemyHit, NormalImpulse) == 0x000018, "Member 'PhxGameplayAbility_PPEEnemySlam_OnEnemyHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemySlam_OnEnemyHit, Hit) == 0x000024, "Member 'PhxGameplayAbility_PPEEnemySlam_OnEnemyHit::Hit' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger.OnActorBeginOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap) == 0x000010, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap, OverlappedActor) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap, OtherActor) == 0x000008, "Member 'PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger.OnActorEndOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap) == 0x000010, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap, OverlappedActor) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap, OtherActor) == 0x000008, "Member 'PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_WaveSpawned.OnWaveSpawned
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIEncounterGroupWaveDescriptor*     WaveDescriptor;                                    // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned) == 0x000010, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned, EncounterGroup) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned, WaveDescriptor) == 0x000008, "Member 'PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned::WaveDescriptor' has a wrong offset!");

// Function Phoenix.PhxAISpawnerInterface.GetSpawnerComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxAISpawnerInterface_GetSpawnerComponent final
{
public:
	class UPhxAISpawnerComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerInterface_GetSpawnerComponent) == 0x000008, "Wrong alignment on PhxAISpawnerInterface_GetSpawnerComponent");
static_assert(sizeof(PhxAISpawnerInterface_GetSpawnerComponent) == 0x000008, "Wrong size on PhxAISpawnerInterface_GetSpawnerComponent");
static_assert(offsetof(PhxAISpawnerInterface_GetSpawnerComponent, ReturnValue) == 0x000000, "Member 'PhxAISpawnerInterface_GetSpawnerComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_WaveCompleted.OnWaveCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIEncounterGroupWaveDescriptor*     WaveDescriptor;                                    // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted) == 0x000010, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted, EncounterGroup) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted, WaveDescriptor) == 0x000008, "Member 'PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted::WaveDescriptor' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_WaveCompleted.OnWaveFakeCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIEncounterGroupWaveDescriptor*     WaveDescriptor;                                    // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted) == 0x000010, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted, EncounterGroup) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted, WaveDescriptor) == 0x000008, "Member 'PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted::WaveDescriptor' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited.OnSafeRoomExited
// 0x0004 (0x0004 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited_OnSafeRoomExited final
{
public:
	int32                                         InSafeRoomIndex;                                   // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited_OnSafeRoomExited) == 0x000004, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited_OnSafeRoomExited");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited_OnSafeRoomExited) == 0x000004, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited_OnSafeRoomExited");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited_OnSafeRoomExited, InSafeRoomIndex) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited_OnSafeRoomExited::InSafeRoomIndex' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned.OnWaveSpawned
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAIEncounterGroupWaveDescriptor*     WaveDescriptor;                                    // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned) == 0x000010, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned, EncounterGroup) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned, WaveDescriptor) == 0x000008, "Member 'PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned::WaveDescriptor' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned.OnNPCKilledOrDestroyed
// 0x0008 (0x0008 - 0x0000)
struct PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned_OnNPCKilledOrDestroyed final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned_OnNPCKilledOrDestroyed) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned_OnNPCKilledOrDestroyed");
static_assert(sizeof(PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned_OnNPCKilledOrDestroyed) == 0x000008, "Wrong size on PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned_OnNPCKilledOrDestroyed");
static_assert(offsetof(PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned_OnNPCKilledOrDestroyed, EncounterGroup) == 0x000000, "Member 'PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned_OnNPCKilledOrDestroyed::EncounterGroup' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase.ReceiveStartPlay
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay");
static_assert(sizeof(PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay) == 0x000010, "Wrong size on PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay");
static_assert(offsetof(PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay, EncounterGroup) == 0x000000, "Member 'PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay, ReturnValue) == 0x000008, "Member 'PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase.ReceiveEvaluateCondition
// 0x0018 (0x0018 - 0x0000)
struct PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition final
{
public:
	class APhxAIEncounterGroup*                   EncounterGroup;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Tag;                                               // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition) == 0x000008, "Wrong alignment on PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition");
static_assert(sizeof(PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition) == 0x000018, "Wrong size on PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition");
static_assert(offsetof(PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition, EncounterGroup) == 0x000000, "Member 'PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition::EncounterGroup' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition, Tag) == 0x000008, "Member 'PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition::Tag' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition, ReturnValue) == 0x000010, "Member 'PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_UseConsumable.OnNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayAbility_UseConsumable_OnNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_UseConsumable_OnNotifyReceived) == 0x000008, "Wrong alignment on PhxGameplayAbility_UseConsumable_OnNotifyReceived");
static_assert(sizeof(PhxGameplayAbility_UseConsumable_OnNotifyReceived) == 0x000008, "Wrong size on PhxGameplayAbility_UseConsumable_OnNotifyReceived");
static_assert(offsetof(PhxGameplayAbility_UseConsumable_OnNotifyReceived, Notify) == 0x000000, "Member 'PhxGameplayAbility_UseConsumable_OnNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxAIEncounterNetwork.HandleAIDestroyed
// 0x0008 (0x0008 - 0x0000)
struct PhxAIEncounterNetwork_HandleAIDestroyed final
{
public:
	class AActor*                                 DestroyedActor;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterNetwork_HandleAIDestroyed) == 0x000008, "Wrong alignment on PhxAIEncounterNetwork_HandleAIDestroyed");
static_assert(sizeof(PhxAIEncounterNetwork_HandleAIDestroyed) == 0x000008, "Wrong size on PhxAIEncounterNetwork_HandleAIDestroyed");
static_assert(offsetof(PhxAIEncounterNetwork_HandleAIDestroyed, DestroyedActor) == 0x000000, "Member 'PhxAIEncounterNetwork_HandleAIDestroyed::DestroyedActor' has a wrong offset!");

// Function Phoenix.PhxAIEncounterNetwork.HandleAIDied
// 0x0020 (0x0020 - 0x0000)
struct PhxAIEncounterNetwork_HandleAIDied final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIEncounterNetwork_HandleAIDied) == 0x000008, "Wrong alignment on PhxAIEncounterNetwork_HandleAIDied");
static_assert(sizeof(PhxAIEncounterNetwork_HandleAIDied) == 0x000020, "Wrong size on PhxAIEncounterNetwork_HandleAIDied");
static_assert(offsetof(PhxAIEncounterNetwork_HandleAIDied, DeadCharacter) == 0x000000, "Member 'PhxAIEncounterNetwork_HandleAIDied::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterNetwork_HandleAIDied, KillerActor) == 0x000008, "Member 'PhxAIEncounterNetwork_HandleAIDied::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterNetwork_HandleAIDied, KillerController) == 0x000010, "Member 'PhxAIEncounterNetwork_HandleAIDied::KillerController' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterNetwork_HandleAIDied, KillingBlowHealthDelta) == 0x000018, "Member 'PhxAIEncounterNetwork_HandleAIDied::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxAIEncounterNetwork.HandleAIInsideStateChanged
// 0x0010 (0x0010 - 0x0000)
struct PhxAIEncounterNetwork_HandleAIInsideStateChanged final
{
public:
	class APhxAICharacter*                        AICharacter;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIEncounterNetworkUserInsideState         OldState;                                          // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIEncounterNetworkUserInsideState         NewState;                                          // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIEncounterNetwork_HandleAIInsideStateChanged) == 0x000008, "Wrong alignment on PhxAIEncounterNetwork_HandleAIInsideStateChanged");
static_assert(sizeof(PhxAIEncounterNetwork_HandleAIInsideStateChanged) == 0x000010, "Wrong size on PhxAIEncounterNetwork_HandleAIInsideStateChanged");
static_assert(offsetof(PhxAIEncounterNetwork_HandleAIInsideStateChanged, AICharacter) == 0x000000, "Member 'PhxAIEncounterNetwork_HandleAIInsideStateChanged::AICharacter' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterNetwork_HandleAIInsideStateChanged, OldState) == 0x000008, "Member 'PhxAIEncounterNetwork_HandleAIInsideStateChanged::OldState' has a wrong offset!");
static_assert(offsetof(PhxAIEncounterNetwork_HandleAIInsideStateChanged, NewState) == 0x000009, "Member 'PhxAIEncounterNetwork_HandleAIInsideStateChanged::NewState' has a wrong offset!");

// Function Phoenix.PhxDoOnceNode.PhxDoOnce
// 0x0018 (0x0018 - 0x0000)
struct PhxDoOnceNode_PhxDoOnce final
{
public:
	class FString                                 Key;                                               // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDoOncePath                                   Path;                                              // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDoOnceNode_PhxDoOnce) == 0x000008, "Wrong alignment on PhxDoOnceNode_PhxDoOnce");
static_assert(sizeof(PhxDoOnceNode_PhxDoOnce) == 0x000018, "Wrong size on PhxDoOnceNode_PhxDoOnce");
static_assert(offsetof(PhxDoOnceNode_PhxDoOnce, Key) == 0x000000, "Member 'PhxDoOnceNode_PhxDoOnce::Key' has a wrong offset!");
static_assert(offsetof(PhxDoOnceNode_PhxDoOnce, Path) == 0x000010, "Member 'PhxDoOnceNode_PhxDoOnce::Path' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.SetAttributeVariation
// 0x0008 (0x0008 - 0x0000)
struct PhxAISpawnerComponent_Character_SetAttributeVariation final
{
public:
	class UPhxAICharacterVariantDefinition*       InAttributeVariation;                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_SetAttributeVariation) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_SetAttributeVariation");
static_assert(sizeof(PhxAISpawnerComponent_Character_SetAttributeVariation) == 0x000008, "Wrong size on PhxAISpawnerComponent_Character_SetAttributeVariation");
static_assert(offsetof(PhxAISpawnerComponent_Character_SetAttributeVariation, InAttributeVariation) == 0x000000, "Member 'PhxAISpawnerComponent_Character_SetAttributeVariation::InAttributeVariation' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.SetBlueprintVariation
// 0x0004 (0x0004 - 0x0000)
struct PhxAISpawnerComponent_Character_SetBlueprintVariation final
{
public:
	int32                                         InBlueprintVariation;                              // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_SetBlueprintVariation) == 0x000004, "Wrong alignment on PhxAISpawnerComponent_Character_SetBlueprintVariation");
static_assert(sizeof(PhxAISpawnerComponent_Character_SetBlueprintVariation) == 0x000004, "Wrong size on PhxAISpawnerComponent_Character_SetBlueprintVariation");
static_assert(offsetof(PhxAISpawnerComponent_Character_SetBlueprintVariation, InBlueprintVariation) == 0x000000, "Member 'PhxAISpawnerComponent_Character_SetBlueprintVariation::InBlueprintVariation' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.SetCharacterDefinition
// 0x0030 (0x0030 - 0x0000)
struct PhxAISpawnerComponent_Character_SetCharacterDefinition final
{
public:
	TSoftObjectPtr<class UPhxAICharacterDefinition> InAICharacterDefinitionPtr;                      // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InCharacterVariation;                              // 0x0028(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAISpawnerComponent_Character_SetCharacterDefinition) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_SetCharacterDefinition");
static_assert(sizeof(PhxAISpawnerComponent_Character_SetCharacterDefinition) == 0x000030, "Wrong size on PhxAISpawnerComponent_Character_SetCharacterDefinition");
static_assert(offsetof(PhxAISpawnerComponent_Character_SetCharacterDefinition, InAICharacterDefinitionPtr) == 0x000000, "Member 'PhxAISpawnerComponent_Character_SetCharacterDefinition::InAICharacterDefinitionPtr' has a wrong offset!");
static_assert(offsetof(PhxAISpawnerComponent_Character_SetCharacterDefinition, InCharacterVariation) == 0x000028, "Member 'PhxAISpawnerComponent_Character_SetCharacterDefinition::InCharacterVariation' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.SetSpawnAwareOfPlayer
// 0x0001 (0x0001 - 0x0000)
struct PhxAISpawnerComponent_Character_SetSpawnAwareOfPlayer final
{
public:
	EPhxAIAwarenessLevel                          InAwarenessLevel;                                  // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_SetSpawnAwareOfPlayer) == 0x000001, "Wrong alignment on PhxAISpawnerComponent_Character_SetSpawnAwareOfPlayer");
static_assert(sizeof(PhxAISpawnerComponent_Character_SetSpawnAwareOfPlayer) == 0x000001, "Wrong size on PhxAISpawnerComponent_Character_SetSpawnAwareOfPlayer");
static_assert(offsetof(PhxAISpawnerComponent_Character_SetSpawnAwareOfPlayer, InAwarenessLevel) == 0x000000, "Member 'PhxAISpawnerComponent_Character_SetSpawnAwareOfPlayer::InAwarenessLevel' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.SetSpawnTags
// 0x0020 (0x0020 - 0x0000)
struct PhxAISpawnerComponent_Character_SetSpawnTags final
{
public:
	struct FGameplayTagContainer                  InSpawnTags;                                       // 0x0000(0x0020)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_SetSpawnTags) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_SetSpawnTags");
static_assert(sizeof(PhxAISpawnerComponent_Character_SetSpawnTags) == 0x000020, "Wrong size on PhxAISpawnerComponent_Character_SetSpawnTags");
static_assert(offsetof(PhxAISpawnerComponent_Character_SetSpawnTags, InSpawnTags) == 0x000000, "Member 'PhxAISpawnerComponent_Character_SetSpawnTags::InSpawnTags' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetAllowPlayerFinisher
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetAllowPlayerFinisher final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetAllowPlayerFinisher) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetAllowPlayerFinisher");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetAllowPlayerFinisher) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetAllowPlayerFinisher");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetAllowPlayerFinisher, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetAllowPlayerFinisher::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetAttributeVariation
// 0x0028 (0x0028 - 0x0000)
struct PhxAISpawnerComponent_Character_GetAttributeVariation final
{
public:
	TSoftObjectPtr<class UPhxAICharacterVariantDefinition> ReturnValue;                              // 0x0000(0x0028)(Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetAttributeVariation) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetAttributeVariation");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetAttributeVariation) == 0x000028, "Wrong size on PhxAISpawnerComponent_Character_GetAttributeVariation");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetAttributeVariation, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetAttributeVariation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetAutoLoad
// 0x0001 (0x0001 - 0x0000)
struct PhxAISpawnerComponent_Character_GetAutoLoad final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetAutoLoad) == 0x000001, "Wrong alignment on PhxAISpawnerComponent_Character_GetAutoLoad");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetAutoLoad) == 0x000001, "Wrong size on PhxAISpawnerComponent_Character_GetAutoLoad");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetAutoLoad, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetAutoLoad::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetAutoRespawn
// 0x0001 (0x0001 - 0x0000)
struct PhxAISpawnerComponent_Character_GetAutoRespawn final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetAutoRespawn) == 0x000001, "Wrong alignment on PhxAISpawnerComponent_Character_GetAutoRespawn");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetAutoRespawn) == 0x000001, "Wrong size on PhxAISpawnerComponent_Character_GetAutoRespawn");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetAutoRespawn, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetAutoRespawn::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetBlueprintVariation
// 0x0004 (0x0004 - 0x0000)
struct PhxAISpawnerComponent_Character_GetBlueprintVariation final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetBlueprintVariation) == 0x000004, "Wrong alignment on PhxAISpawnerComponent_Character_GetBlueprintVariation");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetBlueprintVariation) == 0x000004, "Wrong size on PhxAISpawnerComponent_Character_GetBlueprintVariation");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetBlueprintVariation, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetBlueprintVariation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetCanSpawnOffNavMesh
// 0x0001 (0x0001 - 0x0000)
struct PhxAISpawnerComponent_Character_GetCanSpawnOffNavMesh final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetCanSpawnOffNavMesh) == 0x000001, "Wrong alignment on PhxAISpawnerComponent_Character_GetCanSpawnOffNavMesh");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetCanSpawnOffNavMesh) == 0x000001, "Wrong size on PhxAISpawnerComponent_Character_GetCanSpawnOffNavMesh");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetCanSpawnOffNavMesh, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetCanSpawnOffNavMesh::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetCharacterDefinition
// 0x0028 (0x0028 - 0x0000)
struct PhxAISpawnerComponent_Character_GetCharacterDefinition final
{
public:
	TSoftObjectPtr<class UPhxAICharacterDefinition> ReturnValue;                                     // 0x0000(0x0028)(Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetCharacterDefinition) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetCharacterDefinition");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetCharacterDefinition) == 0x000028, "Wrong size on PhxAISpawnerComponent_Character_GetCharacterDefinition");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetCharacterDefinition, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetCharacterDefinition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetCharacterTag
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetCharacterTag final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetCharacterTag) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetCharacterTag");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetCharacterTag) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetCharacterTag");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetCharacterTag, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetCharacterTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetDefendZone
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetDefendZone final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetDefendZone) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetDefendZone");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetDefendZone) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetDefendZone");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetDefendZone, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetDefendZone::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetDynamicDropsDefinition
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetDynamicDropsDefinition final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetDynamicDropsDefinition) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetDynamicDropsDefinition");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetDynamicDropsDefinition) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetDynamicDropsDefinition");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetDynamicDropsDefinition, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetDynamicDropsDefinition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetEnableVariationAutoPopulation
// 0x0001 (0x0001 - 0x0000)
struct PhxAISpawnerComponent_Character_GetEnableVariationAutoPopulation final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetEnableVariationAutoPopulation) == 0x000001, "Wrong alignment on PhxAISpawnerComponent_Character_GetEnableVariationAutoPopulation");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetEnableVariationAutoPopulation) == 0x000001, "Wrong size on PhxAISpawnerComponent_Character_GetEnableVariationAutoPopulation");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetEnableVariationAutoPopulation, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetEnableVariationAutoPopulation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetEncounterGroup
// 0x0008 (0x0008 - 0x0000)
struct PhxAISpawnerComponent_Character_GetEncounterGroup final
{
public:
	const class APhxAIEncounterGroup*             ReturnValue;                                       // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetEncounterGroup) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetEncounterGroup");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetEncounterGroup) == 0x000008, "Wrong size on PhxAISpawnerComponent_Character_GetEncounterGroup");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetEncounterGroup, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetEncounterGroup::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetMaxSpawns
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetMaxSpawns final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetMaxSpawns) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetMaxSpawns");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetMaxSpawns) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetMaxSpawns");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetMaxSpawns, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetMaxSpawns::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetPatrol
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetPatrol final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetPatrol) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetPatrol");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetPatrol) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetPatrol");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetPatrol, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetPatrol::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetPointOfInterset
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetPointOfInterset final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetPointOfInterset) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetPointOfInterset");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetPointOfInterset) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetPointOfInterset");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetPointOfInterset, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetPointOfInterset::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetPreload
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetPreload final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetPreload) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetPreload");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetPreload) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetPreload");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetPreload, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetPreload::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetScriptngMode
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetScriptngMode final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetScriptngMode) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetScriptngMode");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetScriptngMode) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetScriptngMode");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetScriptngMode, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetScriptngMode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnAnimation
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetSpawnAnimation final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetSpawnAnimation) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetSpawnAnimation");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetSpawnAnimation) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetSpawnAnimation");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetSpawnAnimation, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetSpawnAnimation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnAwareOfPlayer
// 0x0001 (0x0001 - 0x0000)
struct PhxAISpawnerComponent_Character_GetSpawnAwareOfPlayer final
{
public:
	EPhxAIAwarenessLevel                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetSpawnAwareOfPlayer) == 0x000001, "Wrong alignment on PhxAISpawnerComponent_Character_GetSpawnAwareOfPlayer");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetSpawnAwareOfPlayer) == 0x000001, "Wrong size on PhxAISpawnerComponent_Character_GetSpawnAwareOfPlayer");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetSpawnAwareOfPlayer, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetSpawnAwareOfPlayer::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnDialogue
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetSpawnDialogue final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetSpawnDialogue) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetSpawnDialogue");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetSpawnDialogue) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetSpawnDialogue");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetSpawnDialogue, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetSpawnDialogue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnDialogueDelay
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetSpawnDialogueDelay final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetSpawnDialogueDelay) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetSpawnDialogueDelay");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetSpawnDialogueDelay) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetSpawnDialogueDelay");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetSpawnDialogueDelay, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetSpawnDialogueDelay::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnTags
// 0x0010 (0x0010 - 0x0000)
struct PhxAISpawnerComponent_Character_GetSpawnTags final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetSpawnTags) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetSpawnTags");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetSpawnTags) == 0x000010, "Wrong size on PhxAISpawnerComponent_Character_GetSpawnTags");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetSpawnTags, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetSpawnTags::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAISpawnerComponent_Character.GetVocalVariation
// 0x0028 (0x0028 - 0x0000)
struct PhxAISpawnerComponent_Character_GetVocalVariation final
{
public:
	TSoftObjectPtr<class UAkSwitchValue>          ReturnValue;                                       // 0x0000(0x0028)(Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISpawnerComponent_Character_GetVocalVariation) == 0x000008, "Wrong alignment on PhxAISpawnerComponent_Character_GetVocalVariation");
static_assert(sizeof(PhxAISpawnerComponent_Character_GetVocalVariation) == 0x000028, "Wrong size on PhxAISpawnerComponent_Character_GetVocalVariation");
static_assert(offsetof(PhxAISpawnerComponent_Character_GetVocalVariation, ReturnValue) == 0x000000, "Member 'PhxAISpawnerComponent_Character_GetVocalVariation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIEncounterSettingsVolume.DisableHidingPoints
// 0x0004 (0x0004 - 0x0000)
struct PhxAIEncounterSettingsVolume_DisableHidingPoints final
{
public:
	int32                                         NavigationSurfaces;                                // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterSettingsVolume_DisableHidingPoints) == 0x000004, "Wrong alignment on PhxAIEncounterSettingsVolume_DisableHidingPoints");
static_assert(sizeof(PhxAIEncounterSettingsVolume_DisableHidingPoints) == 0x000004, "Wrong size on PhxAIEncounterSettingsVolume_DisableHidingPoints");
static_assert(offsetof(PhxAIEncounterSettingsVolume_DisableHidingPoints, NavigationSurfaces) == 0x000000, "Member 'PhxAIEncounterSettingsVolume_DisableHidingPoints::NavigationSurfaces' has a wrong offset!");

// Function Phoenix.PhxAIEncounterSettingsVolume.EnableHidingPoints
// 0x0004 (0x0004 - 0x0000)
struct PhxAIEncounterSettingsVolume_EnableHidingPoints final
{
public:
	int32                                         NavigationSurfaces;                                // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIEncounterSettingsVolume_EnableHidingPoints) == 0x000004, "Wrong alignment on PhxAIEncounterSettingsVolume_EnableHidingPoints");
static_assert(sizeof(PhxAIEncounterSettingsVolume_EnableHidingPoints) == 0x000004, "Wrong size on PhxAIEncounterSettingsVolume_EnableHidingPoints");
static_assert(offsetof(PhxAIEncounterSettingsVolume_EnableHidingPoints, NavigationSurfaces) == 0x000000, "Member 'PhxAIEncounterSettingsVolume_EnableHidingPoints::NavigationSurfaces' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_Montage.OnEventRecieved
// 0x00B0 (0x00B0 - 0x0000)
struct PhxGameplayAbility_Montage_OnEventRecieved final
{
public:
	struct FGameplayEventData                     EventData;                                         // 0x0000(0x00B0)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_Montage_OnEventRecieved) == 0x000008, "Wrong alignment on PhxGameplayAbility_Montage_OnEventRecieved");
static_assert(sizeof(PhxGameplayAbility_Montage_OnEventRecieved) == 0x0000B0, "Wrong size on PhxGameplayAbility_Montage_OnEventRecieved");
static_assert(offsetof(PhxGameplayAbility_Montage_OnEventRecieved, EventData) == 0x000000, "Member 'PhxGameplayAbility_Montage_OnEventRecieved::EventData' has a wrong offset!");

// Function Phoenix.PhxGRPHitResponseComponent.OnGRPHitBPE
// 0x0038 (0x0038 - 0x0000)
struct PhxGRPHitResponseComponent_OnGRPHitBPE final
{
public:
	struct FPPEHitResponseData                    ResponseData;                                      // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGRPHitResponseComponent_OnGRPHitBPE) == 0x000008, "Wrong alignment on PhxGRPHitResponseComponent_OnGRPHitBPE");
static_assert(sizeof(PhxGRPHitResponseComponent_OnGRPHitBPE) == 0x000038, "Wrong size on PhxGRPHitResponseComponent_OnGRPHitBPE");
static_assert(offsetof(PhxGRPHitResponseComponent_OnGRPHitBPE, ResponseData) == 0x000000, "Member 'PhxGRPHitResponseComponent_OnGRPHitBPE::ResponseData' has a wrong offset!");

// Function Phoenix.PhxGRPHitResponseComponent.OnGRPPushBPE
// 0x0028 (0x0028 - 0x0000)
struct PhxGRPHitResponseComponent_OnGRPPushBPE final
{
public:
	struct FVector                                Direction;                                         // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class AActor*                                 Instigator;                                        // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Weapon;                                            // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShotPower;                                         // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGRPHitResponseComponent_OnGRPPushBPE) == 0x000008, "Wrong alignment on PhxGRPHitResponseComponent_OnGRPPushBPE");
static_assert(sizeof(PhxGRPHitResponseComponent_OnGRPPushBPE) == 0x000028, "Wrong size on PhxGRPHitResponseComponent_OnGRPPushBPE");
static_assert(offsetof(PhxGRPHitResponseComponent_OnGRPPushBPE, Direction) == 0x000000, "Member 'PhxGRPHitResponseComponent_OnGRPPushBPE::Direction' has a wrong offset!");
static_assert(offsetof(PhxGRPHitResponseComponent_OnGRPPushBPE, Instigator) == 0x000010, "Member 'PhxGRPHitResponseComponent_OnGRPPushBPE::Instigator' has a wrong offset!");
static_assert(offsetof(PhxGRPHitResponseComponent_OnGRPPushBPE, Weapon) == 0x000018, "Member 'PhxGRPHitResponseComponent_OnGRPPushBPE::Weapon' has a wrong offset!");
static_assert(offsetof(PhxGRPHitResponseComponent_OnGRPPushBPE, ShotPower) == 0x000020, "Member 'PhxGRPHitResponseComponent_OnGRPPushBPE::ShotPower' has a wrong offset!");

// Function Phoenix.PhxAIPointOfInterestActivatorComponent.SetProximityBubbleScale
// 0x0008 (0x0008 - 0x0000)
struct PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale final
{
public:
	float                                         Radius;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HalfHeight;                                        // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale) == 0x000004, "Wrong alignment on PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale");
static_assert(sizeof(PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale) == 0x000008, "Wrong size on PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale");
static_assert(offsetof(PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale, Radius) == 0x000000, "Member 'PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale::Radius' has a wrong offset!");
static_assert(offsetof(PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale, HalfHeight) == 0x000004, "Member 'PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale::HalfHeight' has a wrong offset!");

// Function Phoenix.PhxAIFightSystem.OnAnyAttackPerformed
// 0x0010 (0x0010 - 0x0000)
struct PhxAIFightSystem_OnAnyAttackPerformed final
{
public:
	class APhxCharacter*                          Attacker;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAttackState*                           AttackState;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIFightSystem_OnAnyAttackPerformed) == 0x000008, "Wrong alignment on PhxAIFightSystem_OnAnyAttackPerformed");
static_assert(sizeof(PhxAIFightSystem_OnAnyAttackPerformed) == 0x000010, "Wrong size on PhxAIFightSystem_OnAnyAttackPerformed");
static_assert(offsetof(PhxAIFightSystem_OnAnyAttackPerformed, Attacker) == 0x000000, "Member 'PhxAIFightSystem_OnAnyAttackPerformed::Attacker' has a wrong offset!");
static_assert(offsetof(PhxAIFightSystem_OnAnyAttackPerformed, AttackState) == 0x000008, "Member 'PhxAIFightSystem_OnAnyAttackPerformed::AttackState' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_Ambush.OnEventRecieved
// 0x00B0 (0x00B0 - 0x0000)
struct PhxAIGameplayAbility_Ambush_OnEventRecieved final
{
public:
	struct FGameplayEventData                     EventData;                                         // 0x0000(0x00B0)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_Ambush_OnEventRecieved) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_Ambush_OnEventRecieved");
static_assert(sizeof(PhxAIGameplayAbility_Ambush_OnEventRecieved) == 0x0000B0, "Wrong size on PhxAIGameplayAbility_Ambush_OnEventRecieved");
static_assert(offsetof(PhxAIGameplayAbility_Ambush_OnEventRecieved, EventData) == 0x000000, "Member 'PhxAIGameplayAbility_Ambush_OnEventRecieved::EventData' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_Ambush.OnReceivedDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxAIGameplayAbility_Ambush_OnReceivedDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_Ambush_OnReceivedDamage) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_Ambush_OnReceivedDamage");
static_assert(sizeof(PhxAIGameplayAbility_Ambush_OnReceivedDamage) == 0x000028, "Wrong size on PhxAIGameplayAbility_Ambush_OnReceivedDamage");
static_assert(offsetof(PhxAIGameplayAbility_Ambush_OnReceivedDamage, DamagedActor) == 0x000000, "Member 'PhxAIGameplayAbility_Ambush_OnReceivedDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Ambush_OnReceivedDamage, Damage) == 0x000008, "Member 'PhxAIGameplayAbility_Ambush_OnReceivedDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Ambush_OnReceivedDamage, DamageType) == 0x000010, "Member 'PhxAIGameplayAbility_Ambush_OnReceivedDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Ambush_OnReceivedDamage, InstigatedBy) == 0x000018, "Member 'PhxAIGameplayAbility_Ambush_OnReceivedDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Ambush_OnReceivedDamage, DamageCauser) == 0x000020, "Member 'PhxAIGameplayAbility_Ambush_OnReceivedDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_AoEAttack.OnAoEAttackNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameplayAbility_AoEAttack_OnAoEAttackNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_AoEAttack_OnAoEAttackNotifyReceived) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_AoEAttack_OnAoEAttackNotifyReceived");
static_assert(sizeof(PhxAIGameplayAbility_AoEAttack_OnAoEAttackNotifyReceived) == 0x000008, "Wrong size on PhxAIGameplayAbility_AoEAttack_OnAoEAttackNotifyReceived");
static_assert(offsetof(PhxAIGameplayAbility_AoEAttack_OnAoEAttackNotifyReceived, Notify) == 0x000000, "Member 'PhxAIGameplayAbility_AoEAttack_OnAoEAttackNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxBloodSpatterTraceManager.ParticleTraceAtLocation
// 0x0168 (0x0168 - 0x0000)
struct PhxBloodSpatterTraceManager_ParticleTraceAtLocation final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNiagaraSystem*                         SystemTemplate;                                    // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SpawnLocation;                                     // 0x0010(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               SpawnRotation;                                     // 0x001C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector                                MotionVector;                                      // 0x0028(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBloodSpatterMaterials                 Materials;                                         // 0x0038(0x0120)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bAllowChunkDecals;                                 // 0x0158(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_159[0x7];                                      // 0x0159(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UNiagaraComponent*                      ReturnValue;                                       // 0x0160(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation) == 0x000008, "Wrong alignment on PhxBloodSpatterTraceManager_ParticleTraceAtLocation");
static_assert(sizeof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation) == 0x000168, "Wrong size on PhxBloodSpatterTraceManager_ParticleTraceAtLocation");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation, WorldContextObject) == 0x000000, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAtLocation::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation, SystemTemplate) == 0x000008, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAtLocation::SystemTemplate' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation, SpawnLocation) == 0x000010, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAtLocation::SpawnLocation' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation, SpawnRotation) == 0x00001C, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAtLocation::SpawnRotation' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation, MotionVector) == 0x000028, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAtLocation::MotionVector' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation, Materials) == 0x000038, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAtLocation::Materials' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation, bAllowChunkDecals) == 0x000158, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAtLocation::bAllowChunkDecals' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAtLocation, ReturnValue) == 0x000160, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAtLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxBloodSpatterTraceManager.ParticleTraceAttached
// 0x0170 (0x0170 - 0x0000)
struct PhxBloodSpatterTraceManager_ParticleTraceAttached final
{
public:
	class UNiagaraSystem*                         SystemTemplate;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USceneComponent*                        AttachTo;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   SocketName;                                        // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                RelativeSpawnLocation;                             // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               RelativeSpawnRotation;                             // 0x0024(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector                                MotionVector;                                      // 0x0030(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBloodSpatterMaterials                 Materials;                                         // 0x0040(0x0120)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bAllowChunkDecals;                                 // 0x0160(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachLocation                               LocationType;                                      // 0x0161(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAutoDestroy;                                      // 0x0162(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_163[0x5];                                      // 0x0163(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
	class UNiagaraComponent*                      ReturnValue;                                       // 0x0168(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBloodSpatterTraceManager_ParticleTraceAttached) == 0x000008, "Wrong alignment on PhxBloodSpatterTraceManager_ParticleTraceAttached");
static_assert(sizeof(PhxBloodSpatterTraceManager_ParticleTraceAttached) == 0x000170, "Wrong size on PhxBloodSpatterTraceManager_ParticleTraceAttached");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, SystemTemplate) == 0x000000, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::SystemTemplate' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, AttachTo) == 0x000008, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::AttachTo' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, SocketName) == 0x000010, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::SocketName' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, RelativeSpawnLocation) == 0x000018, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::RelativeSpawnLocation' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, RelativeSpawnRotation) == 0x000024, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::RelativeSpawnRotation' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, MotionVector) == 0x000030, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::MotionVector' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, Materials) == 0x000040, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::Materials' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, bAllowChunkDecals) == 0x000160, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::bAllowChunkDecals' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, LocationType) == 0x000161, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::LocationType' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, bAutoDestroy) == 0x000162, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::bAutoDestroy' has a wrong offset!");
static_assert(offsetof(PhxBloodSpatterTraceManager_ParticleTraceAttached, ReturnValue) == 0x000168, "Member 'PhxBloodSpatterTraceManager_ParticleTraceAttached::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_BloodwormAttack.OnAttachNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameplayAbility_BloodwormAttack_OnAttachNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_BloodwormAttack_OnAttachNotifyReceived) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_BloodwormAttack_OnAttachNotifyReceived");
static_assert(sizeof(PhxAIGameplayAbility_BloodwormAttack_OnAttachNotifyReceived) == 0x000008, "Wrong size on PhxAIGameplayAbility_BloodwormAttack_OnAttachNotifyReceived");
static_assert(offsetof(PhxAIGameplayAbility_BloodwormAttack_OnAttachNotifyReceived, Notify) == 0x000000, "Member 'PhxAIGameplayAbility_BloodwormAttack_OnAttachNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_BloodwormAttack.OnEquipNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameplayAbility_BloodwormAttack_OnEquipNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_BloodwormAttack_OnEquipNotifyReceived) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_BloodwormAttack_OnEquipNotifyReceived");
static_assert(sizeof(PhxAIGameplayAbility_BloodwormAttack_OnEquipNotifyReceived) == 0x000008, "Wrong size on PhxAIGameplayAbility_BloodwormAttack_OnEquipNotifyReceived");
static_assert(offsetof(PhxAIGameplayAbility_BloodwormAttack_OnEquipNotifyReceived, Notify) == 0x000000, "Member 'PhxAIGameplayAbility_BloodwormAttack_OnEquipNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_BloodwormAttack.OnFinalBlowNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxAIGameplayAbility_BloodwormAttack_OnFinalBlowNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_BloodwormAttack_OnFinalBlowNotifyReceived) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_BloodwormAttack_OnFinalBlowNotifyReceived");
static_assert(sizeof(PhxAIGameplayAbility_BloodwormAttack_OnFinalBlowNotifyReceived) == 0x000008, "Wrong size on PhxAIGameplayAbility_BloodwormAttack_OnFinalBlowNotifyReceived");
static_assert(offsetof(PhxAIGameplayAbility_BloodwormAttack_OnFinalBlowNotifyReceived, Notify) == 0x000000, "Member 'PhxAIGameplayAbility_BloodwormAttack_OnFinalBlowNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_Grapple.OnGrappleStateEntered
// 0x0010 (0x0010 - 0x0000)
struct PhxAIGameplayAbility_Grapple_OnGrappleStateEntered final
{
public:
	class APhxCharacter*                          InCharacter;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAttackState*                           InAttackState;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_Grapple_OnGrappleStateEntered) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_Grapple_OnGrappleStateEntered");
static_assert(sizeof(PhxAIGameplayAbility_Grapple_OnGrappleStateEntered) == 0x000010, "Wrong size on PhxAIGameplayAbility_Grapple_OnGrappleStateEntered");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnGrappleStateEntered, InCharacter) == 0x000000, "Member 'PhxAIGameplayAbility_Grapple_OnGrappleStateEntered::InCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnGrappleStateEntered, InAttackState) == 0x000008, "Member 'PhxAIGameplayAbility_Grapple_OnGrappleStateEntered::InAttackState' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_Grapple.OnGrappleStateExited
// 0x0010 (0x0010 - 0x0000)
struct PhxAIGameplayAbility_Grapple_OnGrappleStateExited final
{
public:
	class APhxCharacter*                          InCharacter;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAttackState*                           InAttackState;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_Grapple_OnGrappleStateExited) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_Grapple_OnGrappleStateExited");
static_assert(sizeof(PhxAIGameplayAbility_Grapple_OnGrappleStateExited) == 0x000010, "Wrong size on PhxAIGameplayAbility_Grapple_OnGrappleStateExited");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnGrappleStateExited, InCharacter) == 0x000000, "Member 'PhxAIGameplayAbility_Grapple_OnGrappleStateExited::InCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnGrappleStateExited, InAttackState) == 0x000008, "Member 'PhxAIGameplayAbility_Grapple_OnGrappleStateExited::InAttackState' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_Grapple.OnQTECompleted
// 0x000C (0x000C - 0x0000)
struct PhxAIGameplayAbility_Grapple_OnQTECompleted final
{
public:
	class FName                                   InQteId;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInResult;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIGameplayAbility_Grapple_OnQTECompleted) == 0x000004, "Wrong alignment on PhxAIGameplayAbility_Grapple_OnQTECompleted");
static_assert(sizeof(PhxAIGameplayAbility_Grapple_OnQTECompleted) == 0x00000C, "Wrong size on PhxAIGameplayAbility_Grapple_OnQTECompleted");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnQTECompleted, InQteId) == 0x000000, "Member 'PhxAIGameplayAbility_Grapple_OnQTECompleted::InQteId' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnQTECompleted, bInResult) == 0x000008, "Member 'PhxAIGameplayAbility_Grapple_OnQTECompleted::bInResult' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_Grapple.OnTargetEnteredPuppetState
// 0x0010 (0x0010 - 0x0000)
struct PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState final
{
public:
	class APhxCharacter*                          TargetCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UGrappledPuppetState*                   TargetGrappledPuppetState;                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState");
static_assert(sizeof(PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState) == 0x000010, "Wrong size on PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState, TargetCharacter) == 0x000000, "Member 'PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState::TargetCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState, TargetGrappledPuppetState) == 0x000008, "Member 'PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState::TargetGrappledPuppetState' has a wrong offset!");

// Function Phoenix.PhxAIGameplayAbility_Grapple.OnTargetExitedPuppetState
// 0x0010 (0x0010 - 0x0000)
struct PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState final
{
public:
	class APhxCharacter*                          TargetCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UGrappledPuppetState*                   TargetGrappledPuppetState;                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState) == 0x000008, "Wrong alignment on PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState");
static_assert(sizeof(PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState) == 0x000010, "Wrong size on PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState, TargetCharacter) == 0x000000, "Member 'PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState::TargetCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState, TargetGrappledPuppetState) == 0x000008, "Member 'PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState::TargetGrappledPuppetState' has a wrong offset!");

// Function Phoenix.PhxPrinterHologram.CreateHologramMaterialForAllSlots
// 0x0010 (0x0010 - 0x0000)
struct PhxPrinterHologram_CreateHologramMaterialForAllSlots final
{
public:
	class UMaterialInstance*                      Distortion;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstance*                      Phantom;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPrinterHologram_CreateHologramMaterialForAllSlots) == 0x000008, "Wrong alignment on PhxPrinterHologram_CreateHologramMaterialForAllSlots");
static_assert(sizeof(PhxPrinterHologram_CreateHologramMaterialForAllSlots) == 0x000010, "Wrong size on PhxPrinterHologram_CreateHologramMaterialForAllSlots");
static_assert(offsetof(PhxPrinterHologram_CreateHologramMaterialForAllSlots, Distortion) == 0x000000, "Member 'PhxPrinterHologram_CreateHologramMaterialForAllSlots::Distortion' has a wrong offset!");
static_assert(offsetof(PhxPrinterHologram_CreateHologramMaterialForAllSlots, Phantom) == 0x000008, "Member 'PhxPrinterHologram_CreateHologramMaterialForAllSlots::Phantom' has a wrong offset!");

// Function Phoenix.PhxPrinterHologram.CreateMaterialForSlot
// 0x0008 (0x0008 - 0x0000)
struct PhxPrinterHologram_CreateMaterialForSlot final
{
public:
	int32                                         SlotIndex;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseHologramMaterial;                              // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPrinterHologram_CreateMaterialForSlot) == 0x000004, "Wrong alignment on PhxPrinterHologram_CreateMaterialForSlot");
static_assert(sizeof(PhxPrinterHologram_CreateMaterialForSlot) == 0x000008, "Wrong size on PhxPrinterHologram_CreateMaterialForSlot");
static_assert(offsetof(PhxPrinterHologram_CreateMaterialForSlot, SlotIndex) == 0x000000, "Member 'PhxPrinterHologram_CreateMaterialForSlot::SlotIndex' has a wrong offset!");
static_assert(offsetof(PhxPrinterHologram_CreateMaterialForSlot, bUseHologramMaterial) == 0x000004, "Member 'PhxPrinterHologram_CreateMaterialForSlot::bUseHologramMaterial' has a wrong offset!");

// Function Phoenix.PhxPrinterHologram.PrepareHologramForWeapon
// 0x0008 (0x0008 - 0x0000)
struct PhxPrinterHologram_PrepareHologramForWeapon final
{
public:
	TSubclassOf<class AWeapon>                    WeaponClass;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPrinterHologram_PrepareHologramForWeapon) == 0x000008, "Wrong alignment on PhxPrinterHologram_PrepareHologramForWeapon");
static_assert(sizeof(PhxPrinterHologram_PrepareHologramForWeapon) == 0x000008, "Wrong size on PhxPrinterHologram_PrepareHologramForWeapon");
static_assert(offsetof(PhxPrinterHologram_PrepareHologramForWeapon, WeaponClass) == 0x000000, "Member 'PhxPrinterHologram_PrepareHologramForWeapon::WeaponClass' has a wrong offset!");

// Function Phoenix.PhxPrinterHologram.SetSkeletalMesh
// 0x0008 (0x0008 - 0x0000)
struct PhxPrinterHologram_SetSkeletalMesh final
{
public:
	class USkeletalMesh*                          SkeletalMesh;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPrinterHologram_SetSkeletalMesh) == 0x000008, "Wrong alignment on PhxPrinterHologram_SetSkeletalMesh");
static_assert(sizeof(PhxPrinterHologram_SetSkeletalMesh) == 0x000008, "Wrong size on PhxPrinterHologram_SetSkeletalMesh");
static_assert(offsetof(PhxPrinterHologram_SetSkeletalMesh, SkeletalMesh) == 0x000000, "Member 'PhxPrinterHologram_SetSkeletalMesh::SkeletalMesh' has a wrong offset!");

// Function Phoenix.PhxPrinterHologram.SetStaticMesh
// 0x0008 (0x0008 - 0x0000)
struct PhxPrinterHologram_SetStaticMesh final
{
public:
	class UStaticMesh*                            StaticMesh;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPrinterHologram_SetStaticMesh) == 0x000008, "Wrong alignment on PhxPrinterHologram_SetStaticMesh");
static_assert(sizeof(PhxPrinterHologram_SetStaticMesh) == 0x000008, "Wrong size on PhxPrinterHologram_SetStaticMesh");
static_assert(offsetof(PhxPrinterHologram_SetStaticMesh, StaticMesh) == 0x000000, "Member 'PhxPrinterHologram_SetStaticMesh::StaticMesh' has a wrong offset!");

// Function Phoenix.PhxPrinterHologram.UpdatePrintHeadHeightParam
// 0x0004 (0x0004 - 0x0000)
struct PhxPrinterHologram_UpdatePrintHeadHeightParam final
{
public:
	float                                         Height;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPrinterHologram_UpdatePrintHeadHeightParam) == 0x000004, "Wrong alignment on PhxPrinterHologram_UpdatePrintHeadHeightParam");
static_assert(sizeof(PhxPrinterHologram_UpdatePrintHeadHeightParam) == 0x000004, "Wrong size on PhxPrinterHologram_UpdatePrintHeadHeightParam");
static_assert(offsetof(PhxPrinterHologram_UpdatePrintHeadHeightParam, Height) == 0x000000, "Member 'PhxPrinterHologram_UpdatePrintHeadHeightParam::Height' has a wrong offset!");

// Function Phoenix.PhxPushableInterface.CanReleasePushable
// 0x0001 (0x0001 - 0x0000)
struct PhxPushableInterface_CanReleasePushable final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPushableInterface_CanReleasePushable) == 0x000001, "Wrong alignment on PhxPushableInterface_CanReleasePushable");
static_assert(sizeof(PhxPushableInterface_CanReleasePushable) == 0x000001, "Wrong size on PhxPushableInterface_CanReleasePushable");
static_assert(offsetof(PhxPushableInterface_CanReleasePushable, ReturnValue) == 0x000000, "Member 'PhxPushableInterface_CanReleasePushable::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPuzzleGrateDoor.OpenGrate
// 0x0001 (0x0001 - 0x0000)
struct PhxPuzzleGrateDoor_OpenGrate final
{
public:
	bool                                          bInstant;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPuzzleGrateDoor_OpenGrate) == 0x000001, "Wrong alignment on PhxPuzzleGrateDoor_OpenGrate");
static_assert(sizeof(PhxPuzzleGrateDoor_OpenGrate) == 0x000001, "Wrong size on PhxPuzzleGrateDoor_OpenGrate");
static_assert(offsetof(PhxPuzzleGrateDoor_OpenGrate, bInstant) == 0x000000, "Member 'PhxPuzzleGrateDoor_OpenGrate::bInstant' has a wrong offset!");

// Function Phoenix.PhxAIMotionComponent.SetMotionTagOverride
// 0x0018 (0x0018 - 0x0000)
struct PhxAIMotionComponent_SetMotionTagOverride final
{
public:
	const class UObject*                          InSource;                                          // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InPriority;                                        // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           InMotionTag;                                       // 0x000C(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InAnalogMovementInputSize;                         // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIMotionComponent_SetMotionTagOverride) == 0x000008, "Wrong alignment on PhxAIMotionComponent_SetMotionTagOverride");
static_assert(sizeof(PhxAIMotionComponent_SetMotionTagOverride) == 0x000018, "Wrong size on PhxAIMotionComponent_SetMotionTagOverride");
static_assert(offsetof(PhxAIMotionComponent_SetMotionTagOverride, InSource) == 0x000000, "Member 'PhxAIMotionComponent_SetMotionTagOverride::InSource' has a wrong offset!");
static_assert(offsetof(PhxAIMotionComponent_SetMotionTagOverride, InPriority) == 0x000008, "Member 'PhxAIMotionComponent_SetMotionTagOverride::InPriority' has a wrong offset!");
static_assert(offsetof(PhxAIMotionComponent_SetMotionTagOverride, InMotionTag) == 0x00000C, "Member 'PhxAIMotionComponent_SetMotionTagOverride::InMotionTag' has a wrong offset!");
static_assert(offsetof(PhxAIMotionComponent_SetMotionTagOverride, InAnalogMovementInputSize) == 0x000014, "Member 'PhxAIMotionComponent_SetMotionTagOverride::InAnalogMovementInputSize' has a wrong offset!");

// Function Phoenix.PhxAIOffensiveActionsComponent.OnDeath
// 0x0020 (0x0020 - 0x0000)
struct PhxAIOffensiveActionsComponent_OnDeath final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxAIOffensiveActionsComponent_OnDeath) == 0x000008, "Wrong alignment on PhxAIOffensiveActionsComponent_OnDeath");
static_assert(sizeof(PhxAIOffensiveActionsComponent_OnDeath) == 0x000020, "Wrong size on PhxAIOffensiveActionsComponent_OnDeath");
static_assert(offsetof(PhxAIOffensiveActionsComponent_OnDeath, DeadCharacter) == 0x000000, "Member 'PhxAIOffensiveActionsComponent_OnDeath::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxAIOffensiveActionsComponent_OnDeath, KillerActor) == 0x000008, "Member 'PhxAIOffensiveActionsComponent_OnDeath::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxAIOffensiveActionsComponent_OnDeath, KillerController) == 0x000010, "Member 'PhxAIOffensiveActionsComponent_OnDeath::KillerController' has a wrong offset!");
static_assert(offsetof(PhxAIOffensiveActionsComponent_OnDeath, KillingBlowHealthDelta) == 0x000018, "Member 'PhxAIOffensiveActionsComponent_OnDeath::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxAIOffensiveActionsComponent.RequestCameraCutKill
// 0x0050 (0x0050 - 0x0000)
struct PhxAIOffensiveActionsComponent_RequestCameraCutKill final
{
public:
	class AWeapon*                                Weapon;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxMeleeAttackDefinition*              Attack;                                            // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 TargetActor;                                       // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_18[0x8];                                       // 0x0018(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTransform                             ContextTransform;                                  // 0x0020(0x0030)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIOffensiveActionsComponent_RequestCameraCutKill) == 0x000010, "Wrong alignment on PhxAIOffensiveActionsComponent_RequestCameraCutKill");
static_assert(sizeof(PhxAIOffensiveActionsComponent_RequestCameraCutKill) == 0x000050, "Wrong size on PhxAIOffensiveActionsComponent_RequestCameraCutKill");
static_assert(offsetof(PhxAIOffensiveActionsComponent_RequestCameraCutKill, Weapon) == 0x000000, "Member 'PhxAIOffensiveActionsComponent_RequestCameraCutKill::Weapon' has a wrong offset!");
static_assert(offsetof(PhxAIOffensiveActionsComponent_RequestCameraCutKill, Attack) == 0x000008, "Member 'PhxAIOffensiveActionsComponent_RequestCameraCutKill::Attack' has a wrong offset!");
static_assert(offsetof(PhxAIOffensiveActionsComponent_RequestCameraCutKill, TargetActor) == 0x000010, "Member 'PhxAIOffensiveActionsComponent_RequestCameraCutKill::TargetActor' has a wrong offset!");
static_assert(offsetof(PhxAIOffensiveActionsComponent_RequestCameraCutKill, ContextTransform) == 0x000020, "Member 'PhxAIOffensiveActionsComponent_RequestCameraCutKill::ContextTransform' has a wrong offset!");

// Function Phoenix.PhxAIProp_BlueprintBase.OnPropTriggered
// 0x0008 (0x0008 - 0x0000)
struct PhxAIProp_BlueprintBase_OnPropTriggered final
{
public:
	class AActor*                                 Triggerer;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAIProp_BlueprintBase_OnPropTriggered) == 0x000008, "Wrong alignment on PhxAIProp_BlueprintBase_OnPropTriggered");
static_assert(sizeof(PhxAIProp_BlueprintBase_OnPropTriggered) == 0x000008, "Wrong size on PhxAIProp_BlueprintBase_OnPropTriggered");
static_assert(offsetof(PhxAIProp_BlueprintBase_OnPropTriggered, Triggerer) == 0x000000, "Member 'PhxAIProp_BlueprintBase_OnPropTriggered::Triggerer' has a wrong offset!");

// Function Phoenix.PhxMemoryBudgetMeterManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxMemoryBudgetMeterManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxMemoryBudgetMeterManager*           ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMemoryBudgetMeterManager_Get) == 0x000008, "Wrong alignment on PhxMemoryBudgetMeterManager_Get");
static_assert(sizeof(PhxMemoryBudgetMeterManager_Get) == 0x000010, "Wrong size on PhxMemoryBudgetMeterManager_Get");
static_assert(offsetof(PhxMemoryBudgetMeterManager_Get, WorldContextObject) == 0x000000, "Member 'PhxMemoryBudgetMeterManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxMemoryBudgetMeterManager_Get, ReturnValue) == 0x000008, "Member 'PhxMemoryBudgetMeterManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMemoryBudgetMeterManager.SetMemoryBudgetMeterVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxMemoryBudgetMeterManager_SetMemoryBudgetMeterVisibility final
{
public:
	ESlateVisibility                              Visibility;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMemoryBudgetMeterManager_SetMemoryBudgetMeterVisibility) == 0x000001, "Wrong alignment on PhxMemoryBudgetMeterManager_SetMemoryBudgetMeterVisibility");
static_assert(sizeof(PhxMemoryBudgetMeterManager_SetMemoryBudgetMeterVisibility) == 0x000001, "Wrong size on PhxMemoryBudgetMeterManager_SetMemoryBudgetMeterVisibility");
static_assert(offsetof(PhxMemoryBudgetMeterManager_SetMemoryBudgetMeterVisibility, Visibility) == 0x000000, "Member 'PhxMemoryBudgetMeterManager_SetMemoryBudgetMeterVisibility::Visibility' has a wrong offset!");

// Function Phoenix.PhxMemoryBudgetMeterManager.GetIsMemoryBudgetMeterVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxMemoryBudgetMeterManager_GetIsMemoryBudgetMeterVisible final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMemoryBudgetMeterManager_GetIsMemoryBudgetMeterVisible) == 0x000001, "Wrong alignment on PhxMemoryBudgetMeterManager_GetIsMemoryBudgetMeterVisible");
static_assert(sizeof(PhxMemoryBudgetMeterManager_GetIsMemoryBudgetMeterVisible) == 0x000001, "Wrong size on PhxMemoryBudgetMeterManager_GetIsMemoryBudgetMeterVisible");
static_assert(offsetof(PhxMemoryBudgetMeterManager_GetIsMemoryBudgetMeterVisible, ReturnValue) == 0x000000, "Member 'PhxMemoryBudgetMeterManager_GetIsMemoryBudgetMeterVisible::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxShipCockpit.RegisterPilotCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxShipCockpit_RegisterPilotCharacter final
{
public:
	class APhxPlayerCharacter*                    PilotCharacter;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxShipCockpit_RegisterPilotCharacter) == 0x000008, "Wrong alignment on PhxShipCockpit_RegisterPilotCharacter");
static_assert(sizeof(PhxShipCockpit_RegisterPilotCharacter) == 0x000008, "Wrong size on PhxShipCockpit_RegisterPilotCharacter");
static_assert(offsetof(PhxShipCockpit_RegisterPilotCharacter, PilotCharacter) == 0x000000, "Member 'PhxShipCockpit_RegisterPilotCharacter::PilotCharacter' has a wrong offset!");

// Function Phoenix.PhxShipCockpit.SetPilotingActive
// 0x0001 (0x0001 - 0x0000)
struct PhxShipCockpit_SetPilotingActive final
{
public:
	bool                                          bNewPilotingActive;                                // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxShipCockpit_SetPilotingActive) == 0x000001, "Wrong alignment on PhxShipCockpit_SetPilotingActive");
static_assert(sizeof(PhxShipCockpit_SetPilotingActive) == 0x000001, "Wrong size on PhxShipCockpit_SetPilotingActive");
static_assert(offsetof(PhxShipCockpit_SetPilotingActive, bNewPilotingActive) == 0x000000, "Member 'PhxShipCockpit_SetPilotingActive::bNewPilotingActive' has a wrong offset!");

// Function Phoenix.PhxSkeletalMeshComponent.DebugDrawJointConstraintViolations
// 0x000C (0x000C - 0x0000)
struct PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations final
{
public:
	float                                         StretchTolerance;                                  // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DrawDuration;                                      // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDrawSkeleton;                                     // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLogMessage;                                       // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x2];                                        // 0x000A(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations) == 0x000004, "Wrong alignment on PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations");
static_assert(sizeof(PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations) == 0x00000C, "Wrong size on PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations");
static_assert(offsetof(PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations, StretchTolerance) == 0x000000, "Member 'PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations::StretchTolerance' has a wrong offset!");
static_assert(offsetof(PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations, DrawDuration) == 0x000004, "Member 'PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations::DrawDuration' has a wrong offset!");
static_assert(offsetof(PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations, bDrawSkeleton) == 0x000008, "Member 'PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations::bDrawSkeleton' has a wrong offset!");
static_assert(offsetof(PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations, bLogMessage) == 0x000009, "Member 'PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations::bLogMessage' has a wrong offset!");

// Function Phoenix.PhxSkeletalMeshComponent.EnforceRagdollConstraints
// 0x0001 (0x0001 - 0x0000)
struct PhxSkeletalMeshComponent_EnforceRagdollConstraints final
{
public:
	bool                                          bLogMessage;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSkeletalMeshComponent_EnforceRagdollConstraints) == 0x000001, "Wrong alignment on PhxSkeletalMeshComponent_EnforceRagdollConstraints");
static_assert(sizeof(PhxSkeletalMeshComponent_EnforceRagdollConstraints) == 0x000001, "Wrong size on PhxSkeletalMeshComponent_EnforceRagdollConstraints");
static_assert(offsetof(PhxSkeletalMeshComponent_EnforceRagdollConstraints, bLogMessage) == 0x000000, "Member 'PhxSkeletalMeshComponent_EnforceRagdollConstraints::bLogMessage' has a wrong offset!");

// Function Phoenix.PhxSkeletalMeshComponent.GetCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxSkeletalMeshComponent_GetCharacter final
{
public:
	class APhxCharacter*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSkeletalMeshComponent_GetCharacter) == 0x000008, "Wrong alignment on PhxSkeletalMeshComponent_GetCharacter");
static_assert(sizeof(PhxSkeletalMeshComponent_GetCharacter) == 0x000008, "Wrong size on PhxSkeletalMeshComponent_GetCharacter");
static_assert(offsetof(PhxSkeletalMeshComponent_GetCharacter, ReturnValue) == 0x000000, "Member 'PhxSkeletalMeshComponent_GetCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSlider.ChangeValue
// 0x0001 (0x0001 - 0x0000)
struct PhxSlider_ChangeValue final
{
public:
	bool                                          bIncrement;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSlider_ChangeValue) == 0x000001, "Wrong alignment on PhxSlider_ChangeValue");
static_assert(sizeof(PhxSlider_ChangeValue) == 0x000001, "Wrong size on PhxSlider_ChangeValue");
static_assert(offsetof(PhxSlider_ChangeValue, bIncrement) == 0x000000, "Member 'PhxSlider_ChangeValue::bIncrement' has a wrong offset!");

// Function Phoenix.PhxSlider.SetLabel
// 0x0018 (0x0018 - 0x0000)
struct PhxSlider_SetLabel final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSlider_SetLabel) == 0x000008, "Wrong alignment on PhxSlider_SetLabel");
static_assert(sizeof(PhxSlider_SetLabel) == 0x000018, "Wrong size on PhxSlider_SetLabel");
static_assert(offsetof(PhxSlider_SetLabel, InText) == 0x000000, "Member 'PhxSlider_SetLabel::InText' has a wrong offset!");

// Function Phoenix.PhxSlider.SetSliderValue
// 0x0008 (0x0008 - 0x0000)
struct PhxSlider_SetSliderValue final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bBroadcast;                                        // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSlider_SetSliderValue) == 0x000004, "Wrong alignment on PhxSlider_SetSliderValue");
static_assert(sizeof(PhxSlider_SetSliderValue) == 0x000008, "Wrong size on PhxSlider_SetSliderValue");
static_assert(offsetof(PhxSlider_SetSliderValue, InValue) == 0x000000, "Member 'PhxSlider_SetSliderValue::InValue' has a wrong offset!");
static_assert(offsetof(PhxSlider_SetSliderValue, bBroadcast) == 0x000004, "Member 'PhxSlider_SetSliderValue::bBroadcast' has a wrong offset!");

// Function Phoenix.PhxSlider.GetSliderValue
// 0x0004 (0x0004 - 0x0000)
struct PhxSlider_GetSliderValue final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSlider_GetSliderValue) == 0x000004, "Wrong alignment on PhxSlider_GetSliderValue");
static_assert(sizeof(PhxSlider_GetSliderValue) == 0x000004, "Wrong size on PhxSlider_GetSliderValue");
static_assert(offsetof(PhxSlider_GetSliderValue, ReturnValue) == 0x000000, "Member 'PhxSlider_GetSliderValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMine.HandleTakeAnyDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxMine_HandleTakeAnyDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMine_HandleTakeAnyDamage) == 0x000008, "Wrong alignment on PhxMine_HandleTakeAnyDamage");
static_assert(sizeof(PhxMine_HandleTakeAnyDamage) == 0x000028, "Wrong size on PhxMine_HandleTakeAnyDamage");
static_assert(offsetof(PhxMine_HandleTakeAnyDamage, DamagedActor) == 0x000000, "Member 'PhxMine_HandleTakeAnyDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxMine_HandleTakeAnyDamage, Damage) == 0x000008, "Member 'PhxMine_HandleTakeAnyDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxMine_HandleTakeAnyDamage, DamageType) == 0x000010, "Member 'PhxMine_HandleTakeAnyDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxMine_HandleTakeAnyDamage, InstigatedBy) == 0x000018, "Member 'PhxMine_HandleTakeAnyDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxMine_HandleTakeAnyDamage, DamageCauser) == 0x000020, "Member 'PhxMine_HandleTakeAnyDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxMine.OnProximityBoxBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxMine_OnProximityBoxBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMine_OnProximityBoxBeginOverlap) == 0x000008, "Wrong alignment on PhxMine_OnProximityBoxBeginOverlap");
static_assert(sizeof(PhxMine_OnProximityBoxBeginOverlap) == 0x0000A8, "Wrong size on PhxMine_OnProximityBoxBeginOverlap");
static_assert(offsetof(PhxMine_OnProximityBoxBeginOverlap, OverlappedComponent) == 0x000000, "Member 'PhxMine_OnProximityBoxBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxMine_OnProximityBoxBeginOverlap, OtherActor) == 0x000008, "Member 'PhxMine_OnProximityBoxBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxMine_OnProximityBoxBeginOverlap, OtherComp) == 0x000010, "Member 'PhxMine_OnProximityBoxBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxMine_OnProximityBoxBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxMine_OnProximityBoxBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxMine_OnProximityBoxBeginOverlap, bFromSweep) == 0x00001C, "Member 'PhxMine_OnProximityBoxBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxMine_OnProximityBoxBeginOverlap, SweepResult) == 0x000020, "Member 'PhxMine_OnProximityBoxBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxAISensor_Damage.HandleTakeAnyDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxAISensor_Damage_HandleTakeAnyDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAISensor_Damage_HandleTakeAnyDamage) == 0x000008, "Wrong alignment on PhxAISensor_Damage_HandleTakeAnyDamage");
static_assert(sizeof(PhxAISensor_Damage_HandleTakeAnyDamage) == 0x000028, "Wrong size on PhxAISensor_Damage_HandleTakeAnyDamage");
static_assert(offsetof(PhxAISensor_Damage_HandleTakeAnyDamage, DamagedActor) == 0x000000, "Member 'PhxAISensor_Damage_HandleTakeAnyDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Damage_HandleTakeAnyDamage, Damage) == 0x000008, "Member 'PhxAISensor_Damage_HandleTakeAnyDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Damage_HandleTakeAnyDamage, DamageType) == 0x000010, "Member 'PhxAISensor_Damage_HandleTakeAnyDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Damage_HandleTakeAnyDamage, InstigatedBy) == 0x000018, "Member 'PhxAISensor_Damage_HandleTakeAnyDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxAISensor_Damage_HandleTakeAnyDamage, DamageCauser) == 0x000020, "Member 'PhxAISensor_Damage_HandleTakeAnyDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.AddActivePerk
// 0x0002 (0x0002 - 0x0000)
struct PhoenixRiotModeSubSytem_AddActivePerk final
{
public:
	EPhxRiotModePerkType                          PerkType;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0001(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_AddActivePerk) == 0x000001, "Wrong alignment on PhoenixRiotModeSubSytem_AddActivePerk");
static_assert(sizeof(PhoenixRiotModeSubSytem_AddActivePerk) == 0x000002, "Wrong size on PhoenixRiotModeSubSytem_AddActivePerk");
static_assert(offsetof(PhoenixRiotModeSubSytem_AddActivePerk, PerkType) == 0x000000, "Member 'PhoenixRiotModeSubSytem_AddActivePerk::PerkType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_AddActivePerk, ReturnValue) == 0x000001, "Member 'PhoenixRiotModeSubSytem_AddActivePerk::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.CheckForDismemberments
// 0x0020 (0x0020 - 0x0000)
struct PhoenixRiotModeSubSytem_CheckForDismemberments final
{
public:
	TArray<EPhxBodyPartType>                      BodyPartTypes;                                     // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
	class AActor*                                 Instigator;                                        // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OwningChacter;                                     // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_CheckForDismemberments) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_CheckForDismemberments");
static_assert(sizeof(PhoenixRiotModeSubSytem_CheckForDismemberments) == 0x000020, "Wrong size on PhoenixRiotModeSubSytem_CheckForDismemberments");
static_assert(offsetof(PhoenixRiotModeSubSytem_CheckForDismemberments, BodyPartTypes) == 0x000000, "Member 'PhoenixRiotModeSubSytem_CheckForDismemberments::BodyPartTypes' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_CheckForDismemberments, Instigator) == 0x000010, "Member 'PhoenixRiotModeSubSytem_CheckForDismemberments::Instigator' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_CheckForDismemberments, OwningChacter) == 0x000018, "Member 'PhoenixRiotModeSubSytem_CheckForDismemberments::OwningChacter' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnCharacterDiedFromGRPCollision
// 0x0008 (0x0008 - 0x0000)
struct PhoenixRiotModeSubSytem_OnCharacterDiedFromGRPCollision final
{
public:
	const class APhxCharacter*                    Character;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnCharacterDiedFromGRPCollision) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_OnCharacterDiedFromGRPCollision");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnCharacterDiedFromGRPCollision) == 0x000008, "Wrong size on PhoenixRiotModeSubSytem_OnCharacterDiedFromGRPCollision");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnCharacterDiedFromGRPCollision, Character) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnCharacterDiedFromGRPCollision::Character' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnEnemyDied
// 0x0018 (0x0018 - 0x0000)
struct PhoenixRiotModeSubSytem_OnEnemyDied final
{
public:
	class UPhxAIGameStateManager*                 AIGameStateManager;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnEnemyDied) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_OnEnemyDied");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnEnemyDied) == 0x000018, "Wrong size on PhoenixRiotModeSubSytem_OnEnemyDied");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnEnemyDied, AIGameStateManager) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnEnemyDied::AIGameStateManager' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnEnemyDied, Enemy) == 0x000008, "Member 'PhoenixRiotModeSubSytem_OnEnemyDied::Enemy' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnEnemyDied, KillerController) == 0x000010, "Member 'PhoenixRiotModeSubSytem_OnEnemyDied::KillerController' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnEnemySpawned
// 0x0010 (0x0010 - 0x0000)
struct PhoenixRiotModeSubSytem_OnEnemySpawned final
{
public:
	class UPhxAIGameStateManager*                 AIGameStateManager;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnEnemySpawned) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_OnEnemySpawned");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnEnemySpawned) == 0x000010, "Wrong size on PhoenixRiotModeSubSytem_OnEnemySpawned");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnEnemySpawned, AIGameStateManager) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnEnemySpawned::AIGameStateManager' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnEnemySpawned, Enemy) == 0x000008, "Member 'PhoenixRiotModeSubSytem_OnEnemySpawned::Enemy' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnHordeWaveCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhoenixRiotModeSubSytem_OnHordeWaveCompleted final
{
public:
	class APhxAIHordeEncounterGroup*              InHordeEncounterGroup;                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         HordeWaveIndex;                                    // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnHordeWaveCompleted) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_OnHordeWaveCompleted");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnHordeWaveCompleted) == 0x000010, "Wrong size on PhoenixRiotModeSubSytem_OnHordeWaveCompleted");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnHordeWaveCompleted, InHordeEncounterGroup) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnHordeWaveCompleted::InHordeEncounterGroup' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnHordeWaveCompleted, HordeWaveIndex) == 0x000008, "Member 'PhoenixRiotModeSubSytem_OnHordeWaveCompleted::HordeWaveIndex' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnItemPurchasedFromLootCrate
// 0x0010 (0x0010 - 0x0000)
struct PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate final
{
public:
	int32                                         CreditsSpent;                                      // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ItemName;                                          // 0x0004(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ItemTier;                                          // 0x000C(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate) == 0x000010, "Wrong size on PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate, CreditsSpent) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate::CreditsSpent' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate, ItemName) == 0x000004, "Member 'PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate::ItemName' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate, ItemTier) == 0x00000C, "Member 'PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate::ItemTier' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnNewHitRecorded
// 0x0108 (0x0108 - 0x0000)
struct PhoenixRiotModeSubSytem_OnNewHitRecorded final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxCharacterHealthComponent*     HealthComponent;                                   // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitRecord                             HitRecord;                                         // 0x0010(0x00F8)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnNewHitRecorded) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_OnNewHitRecorded");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnNewHitRecorded) == 0x000108, "Wrong size on PhoenixRiotModeSubSytem_OnNewHitRecorded");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnNewHitRecorded, Character) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnNewHitRecorded::Character' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnNewHitRecorded, HealthComponent) == 0x000008, "Member 'PhoenixRiotModeSubSytem_OnNewHitRecorded::HealthComponent' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnNewHitRecorded, HitRecord) == 0x000010, "Member 'PhoenixRiotModeSubSytem_OnNewHitRecorded::HitRecord' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerDefensiveActionInitiated
// 0x0100 (0x0100 - 0x0000)
struct PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated final
{
public:
	EReactionType                                 ReactionType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefensiveReactDirection                      ReactionDir;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2[0x6];                                        // 0x0002(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitRecord                             HitRecord;                                         // 0x0008(0x00F8)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated) == 0x000100, "Wrong size on PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated, ReactionType) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated::ReactionType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated, ReactionDir) == 0x000001, "Member 'PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated::ReactionDir' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated, HitRecord) == 0x000008, "Member 'PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated::HitRecord' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerDied
// 0x0020 (0x0020 - 0x0000)
struct PhoenixRiotModeSubSytem_OnPlayerDied final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnPlayerDied) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_OnPlayerDied");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnPlayerDied) == 0x000020, "Wrong size on PhoenixRiotModeSubSytem_OnPlayerDied");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerDied, DeadCharacter) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnPlayerDied::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerDied, KillerActor) == 0x000008, "Member 'PhoenixRiotModeSubSytem_OnPlayerDied::KillerActor' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerDied, KillerController) == 0x000010, "Member 'PhoenixRiotModeSubSytem_OnPlayerDied::KillerController' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerDied, KillingBlowHealthDelta) == 0x000018, "Member 'PhoenixRiotModeSubSytem_OnPlayerDied::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerInventoryChanged
// 0x000C (0x000C - 0x0000)
struct PhoenixRiotModeSubSytem_OnPlayerInventoryChanged final
{
public:
	class FName                                   ItemName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Quantity;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnPlayerInventoryChanged) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_OnPlayerInventoryChanged");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnPlayerInventoryChanged) == 0x00000C, "Wrong size on PhoenixRiotModeSubSytem_OnPlayerInventoryChanged");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerInventoryChanged, ItemName) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnPlayerInventoryChanged::ItemName' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerInventoryChanged, Quantity) == 0x000008, "Member 'PhoenixRiotModeSubSytem_OnPlayerInventoryChanged::Quantity' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerItemConsumed
// 0x0100 (0x0100 - 0x0000)
struct PhoenixRiotModeSubSytem_OnPlayerItemConsumed final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnPlayerItemConsumed) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_OnPlayerItemConsumed");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnPlayerItemConsumed) == 0x000100, "Wrong size on PhoenixRiotModeSubSytem_OnPlayerItemConsumed");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerItemConsumed, ItemData) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnPlayerItemConsumed::ItemData' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerTraversalInitiated
// 0x0028 (0x0028 - 0x0000)
struct PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated final
{
public:
	class APhxPlayerCharacter*                    Player;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTagContainer                  AbilityTags;                                       // 0x0008(0x0020)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated) == 0x000028, "Wrong size on PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated, Player) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated::Player' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated, AbilityTags) == 0x000008, "Member 'PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated::AbilityTags' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.OnSafeRoomExited
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_OnSafeRoomExited final
{
public:
	int32                                         SafeRoomIndex;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_OnSafeRoomExited) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_OnSafeRoomExited");
static_assert(sizeof(PhoenixRiotModeSubSytem_OnSafeRoomExited) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_OnSafeRoomExited");
static_assert(offsetof(PhoenixRiotModeSubSytem_OnSafeRoomExited, SafeRoomIndex) == 0x000000, "Member 'PhoenixRiotModeSubSytem_OnSafeRoomExited::SafeRoomIndex' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.RecordRiotModeGameplayStat
// 0x000C (0x000C - 0x0000)
struct PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat final
{
public:
	EPhxRiotModeStatType                          StatType;                                          // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTag                           CharacterTag;                                      // 0x0004(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat");
static_assert(sizeof(PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat) == 0x00000C, "Wrong size on PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat");
static_assert(offsetof(PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat, StatType) == 0x000000, "Member 'PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat::StatType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat, CharacterTag) == 0x000004, "Member 'PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat::CharacterTag' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.RemoveActivePerk
// 0x0001 (0x0001 - 0x0000)
struct PhoenixRiotModeSubSytem_RemoveActivePerk final
{
public:
	EPhxRiotModePerkType                          PerkType;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_RemoveActivePerk) == 0x000001, "Wrong alignment on PhoenixRiotModeSubSytem_RemoveActivePerk");
static_assert(sizeof(PhoenixRiotModeSubSytem_RemoveActivePerk) == 0x000001, "Wrong size on PhoenixRiotModeSubSytem_RemoveActivePerk");
static_assert(offsetof(PhoenixRiotModeSubSytem_RemoveActivePerk, PerkType) == 0x000000, "Member 'PhoenixRiotModeSubSytem_RemoveActivePerk::PerkType' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.SetCurrentWave
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_SetCurrentWave final
{
public:
	int32                                         WaveNumber;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_SetCurrentWave) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_SetCurrentWave");
static_assert(sizeof(PhoenixRiotModeSubSytem_SetCurrentWave) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_SetCurrentWave");
static_assert(offsetof(PhoenixRiotModeSubSytem_SetCurrentWave, WaveNumber) == 0x000000, "Member 'PhoenixRiotModeSubSytem_SetCurrentWave::WaveNumber' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.UnlockPerk
// 0x0001 (0x0001 - 0x0000)
struct PhoenixRiotModeSubSytem_UnlockPerk final
{
public:
	EPhxRiotModePerkType                          PerkType;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_UnlockPerk) == 0x000001, "Wrong alignment on PhoenixRiotModeSubSytem_UnlockPerk");
static_assert(sizeof(PhoenixRiotModeSubSytem_UnlockPerk) == 0x000001, "Wrong size on PhoenixRiotModeSubSytem_UnlockPerk");
static_assert(offsetof(PhoenixRiotModeSubSytem_UnlockPerk, PerkType) == 0x000000, "Member 'PhoenixRiotModeSubSytem_UnlockPerk::PerkType' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.ActiveModifierTimeRemaining
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_ActiveModifierTimeRemaining final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_ActiveModifierTimeRemaining) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_ActiveModifierTimeRemaining");
static_assert(sizeof(PhoenixRiotModeSubSytem_ActiveModifierTimeRemaining) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_ActiveModifierTimeRemaining");
static_assert(offsetof(PhoenixRiotModeSubSytem_ActiveModifierTimeRemaining, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_ActiveModifierTimeRemaining::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetCurrentComboTimeRemaining
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_GetCurrentComboTimeRemaining final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetCurrentComboTimeRemaining) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetCurrentComboTimeRemaining");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetCurrentComboTimeRemaining) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_GetCurrentComboTimeRemaining");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetCurrentComboTimeRemaining, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetCurrentComboTimeRemaining::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetCurrentComboValue
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_GetCurrentComboValue final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetCurrentComboValue) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetCurrentComboValue");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetCurrentComboValue) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_GetCurrentComboValue");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetCurrentComboValue, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetCurrentComboValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetCurrentWave
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_GetCurrentWave final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetCurrentWave) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetCurrentWave");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetCurrentWave) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_GetCurrentWave");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetCurrentWave, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetCurrentWave::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetMaxComboTimer
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_GetMaxComboTimer final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetMaxComboTimer) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetMaxComboTimer");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetMaxComboTimer) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_GetMaxComboTimer");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetMaxComboTimer, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetMaxComboTimer::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetMaxComboValue
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_GetMaxComboValue final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetMaxComboValue) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetMaxComboValue");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetMaxComboValue) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_GetMaxComboValue");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetMaxComboValue, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetMaxComboValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetPointValueForStat
// 0x0010 (0x0010 - 0x0000)
struct PhoenixRiotModeSubSytem_GetPointValueForStat final
{
public:
	struct FGameplayTag                           CharacterTag;                                      // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxRiotModeStatType                          StatType;                                          // 0x0008(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ReturnValue;                                       // 0x000C(0x0004)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetPointValueForStat) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetPointValueForStat");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetPointValueForStat) == 0x000010, "Wrong size on PhoenixRiotModeSubSytem_GetPointValueForStat");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetPointValueForStat, CharacterTag) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetPointValueForStat::CharacterTag' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetPointValueForStat, StatType) == 0x000008, "Member 'PhoenixRiotModeSubSytem_GetPointValueForStat::StatType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetPointValueForStat, ReturnValue) == 0x00000C, "Member 'PhoenixRiotModeSubSytem_GetPointValueForStat::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetStatCount
// 0x0008 (0x0008 - 0x0000)
struct PhoenixRiotModeSubSytem_GetStatCount final
{
public:
	EPhxRiotModeStatType                          StatType;                                          // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ReturnValue;                                       // 0x0004(0x0004)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetStatCount) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetStatCount");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetStatCount) == 0x000008, "Wrong size on PhoenixRiotModeSubSytem_GetStatCount");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetStatCount, StatType) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetStatCount::StatType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetStatCount, ReturnValue) == 0x000004, "Member 'PhoenixRiotModeSubSytem_GetStatCount::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetStatRecordForCharacter
// 0x0024 (0x0024 - 0x0000)
struct PhoenixRiotModeSubSytem_GetStatRecordForCharacter final
{
public:
	struct FGameplayTag                           CharacterTag;                                      // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxRiotModeStatType                          StatType;                                          // 0x0008(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRiotModeStatRecord                    ReturnValue;                                       // 0x000C(0x0018)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetStatRecordForCharacter) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetStatRecordForCharacter");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetStatRecordForCharacter) == 0x000024, "Wrong size on PhoenixRiotModeSubSytem_GetStatRecordForCharacter");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetStatRecordForCharacter, CharacterTag) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetStatRecordForCharacter::CharacterTag' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetStatRecordForCharacter, StatType) == 0x000008, "Member 'PhoenixRiotModeSubSytem_GetStatRecordForCharacter::StatType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetStatRecordForCharacter, ReturnValue) == 0x00000C, "Member 'PhoenixRiotModeSubSytem_GetStatRecordForCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetStatTotalCount
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_GetStatTotalCount final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetStatTotalCount) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetStatTotalCount");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetStatTotalCount) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_GetStatTotalCount");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetStatTotalCount, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetStatTotalCount::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetStatTotalPoints
// 0x0008 (0x0008 - 0x0000)
struct PhoenixRiotModeSubSytem_GetStatTotalPoints final
{
public:
	EPhxRiotModeStatType                          StatType;                                          // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ReturnValue;                                       // 0x0004(0x0004)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetStatTotalPoints) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetStatTotalPoints");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetStatTotalPoints) == 0x000008, "Wrong size on PhoenixRiotModeSubSytem_GetStatTotalPoints");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetStatTotalPoints, StatType) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetStatTotalPoints::StatType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetStatTotalPoints, ReturnValue) == 0x000004, "Member 'PhoenixRiotModeSubSytem_GetStatTotalPoints::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetTableRowDataForStat
// 0x0028 (0x0028 - 0x0000)
struct PhoenixRiotModeSubSytem_GetTableRowDataForStat final
{
public:
	struct FGameplayTag                           CharacterTag;                                      // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxRiotModeStatType                          StatType;                                          // 0x0008(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRiotModeStatDataRow                   ReturnValue;                                       // 0x0010(0x0018)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetTableRowDataForStat) == 0x000008, "Wrong alignment on PhoenixRiotModeSubSytem_GetTableRowDataForStat");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetTableRowDataForStat) == 0x000028, "Wrong size on PhoenixRiotModeSubSytem_GetTableRowDataForStat");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetTableRowDataForStat, CharacterTag) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetTableRowDataForStat::CharacterTag' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetTableRowDataForStat, StatType) == 0x000008, "Member 'PhoenixRiotModeSubSytem_GetTableRowDataForStat::StatType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetTableRowDataForStat, ReturnValue) == 0x000010, "Member 'PhoenixRiotModeSubSytem_GetTableRowDataForStat::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.GetTotalPoints
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_GetTotalPoints final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_GetTotalPoints) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_GetTotalPoints");
static_assert(sizeof(PhoenixRiotModeSubSytem_GetTotalPoints) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_GetTotalPoints");
static_assert(offsetof(PhoenixRiotModeSubSytem_GetTotalPoints, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_GetTotalPoints::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.IsModifierAvailable
// 0x0001 (0x0001 - 0x0000)
struct PhoenixRiotModeSubSytem_IsModifierAvailable final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_IsModifierAvailable) == 0x000001, "Wrong alignment on PhoenixRiotModeSubSytem_IsModifierAvailable");
static_assert(sizeof(PhoenixRiotModeSubSytem_IsModifierAvailable) == 0x000001, "Wrong size on PhoenixRiotModeSubSytem_IsModifierAvailable");
static_assert(offsetof(PhoenixRiotModeSubSytem_IsModifierAvailable, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_IsModifierAvailable::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.IsPerkActive
// 0x0002 (0x0002 - 0x0000)
struct PhoenixRiotModeSubSytem_IsPerkActive final
{
public:
	EPhxRiotModePerkType                          PerkType;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0001(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_IsPerkActive) == 0x000001, "Wrong alignment on PhoenixRiotModeSubSytem_IsPerkActive");
static_assert(sizeof(PhoenixRiotModeSubSytem_IsPerkActive) == 0x000002, "Wrong size on PhoenixRiotModeSubSytem_IsPerkActive");
static_assert(offsetof(PhoenixRiotModeSubSytem_IsPerkActive, PerkType) == 0x000000, "Member 'PhoenixRiotModeSubSytem_IsPerkActive::PerkType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_IsPerkActive, ReturnValue) == 0x000001, "Member 'PhoenixRiotModeSubSytem_IsPerkActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.IsPerkUnlocked
// 0x0002 (0x0002 - 0x0000)
struct PhoenixRiotModeSubSytem_IsPerkUnlocked final
{
public:
	EPhxRiotModePerkType                          PerkType;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0001(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_IsPerkUnlocked) == 0x000001, "Wrong alignment on PhoenixRiotModeSubSytem_IsPerkUnlocked");
static_assert(sizeof(PhoenixRiotModeSubSytem_IsPerkUnlocked) == 0x000002, "Wrong size on PhoenixRiotModeSubSytem_IsPerkUnlocked");
static_assert(offsetof(PhoenixRiotModeSubSytem_IsPerkUnlocked, PerkType) == 0x000000, "Member 'PhoenixRiotModeSubSytem_IsPerkUnlocked::PerkType' has a wrong offset!");
static_assert(offsetof(PhoenixRiotModeSubSytem_IsPerkUnlocked, ReturnValue) == 0x000001, "Member 'PhoenixRiotModeSubSytem_IsPerkUnlocked::ReturnValue' has a wrong offset!");

// Function Phoenix.PhoenixRiotModeSubSytem.ScoreNeededForModifier
// 0x0004 (0x0004 - 0x0000)
struct PhoenixRiotModeSubSytem_ScoreNeededForModifier final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhoenixRiotModeSubSytem_ScoreNeededForModifier) == 0x000004, "Wrong alignment on PhoenixRiotModeSubSytem_ScoreNeededForModifier");
static_assert(sizeof(PhoenixRiotModeSubSytem_ScoreNeededForModifier) == 0x000004, "Wrong size on PhoenixRiotModeSubSytem_ScoreNeededForModifier");
static_assert(offsetof(PhoenixRiotModeSubSytem_ScoreNeededForModifier, ReturnValue) == 0x000000, "Member 'PhoenixRiotModeSubSytem_ScoreNeededForModifier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMeleeAttackTester.GetCurrentAttackStage
// 0x0001 (0x0001 - 0x0000)
struct PhxMeleeAttackTester_GetCurrentAttackStage final
{
public:
	EMeleeAttackTesterStage                       ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMeleeAttackTester_GetCurrentAttackStage) == 0x000001, "Wrong alignment on PhxMeleeAttackTester_GetCurrentAttackStage");
static_assert(sizeof(PhxMeleeAttackTester_GetCurrentAttackStage) == 0x000001, "Wrong size on PhxMeleeAttackTester_GetCurrentAttackStage");
static_assert(offsetof(PhxMeleeAttackTester_GetCurrentAttackStage, ReturnValue) == 0x000000, "Member 'PhxMeleeAttackTester_GetCurrentAttackStage::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.GetGraphTitle
// 0x0018 (0x0018 - 0x0000)
struct PhxAllocationTrackerWidget_GetGraphTitle final
{
public:
	int32                                         GraphIndex;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_GetGraphTitle) == 0x000008, "Wrong alignment on PhxAllocationTrackerWidget_GetGraphTitle");
static_assert(sizeof(PhxAllocationTrackerWidget_GetGraphTitle) == 0x000018, "Wrong size on PhxAllocationTrackerWidget_GetGraphTitle");
static_assert(offsetof(PhxAllocationTrackerWidget_GetGraphTitle, GraphIndex) == 0x000000, "Member 'PhxAllocationTrackerWidget_GetGraphTitle::GraphIndex' has a wrong offset!");
static_assert(offsetof(PhxAllocationTrackerWidget_GetGraphTitle, ReturnValue) == 0x000008, "Member 'PhxAllocationTrackerWidget_GetGraphTitle::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.GetMessage
// 0x0018 (0x0018 - 0x0000)
struct PhxAllocationTrackerWidget_GetMessage final
{
public:
	int32                                         MessageIndex;                                      // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_GetMessage) == 0x000008, "Wrong alignment on PhxAllocationTrackerWidget_GetMessage");
static_assert(sizeof(PhxAllocationTrackerWidget_GetMessage) == 0x000018, "Wrong size on PhxAllocationTrackerWidget_GetMessage");
static_assert(offsetof(PhxAllocationTrackerWidget_GetMessage, MessageIndex) == 0x000000, "Member 'PhxAllocationTrackerWidget_GetMessage::MessageIndex' has a wrong offset!");
static_assert(offsetof(PhxAllocationTrackerWidget_GetMessage, ReturnValue) == 0x000008, "Member 'PhxAllocationTrackerWidget_GetMessage::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.GetPageTitle
// 0x0010 (0x0010 - 0x0000)
struct PhxAllocationTrackerWidget_GetPageTitle final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_GetPageTitle) == 0x000008, "Wrong alignment on PhxAllocationTrackerWidget_GetPageTitle");
static_assert(sizeof(PhxAllocationTrackerWidget_GetPageTitle) == 0x000010, "Wrong size on PhxAllocationTrackerWidget_GetPageTitle");
static_assert(offsetof(PhxAllocationTrackerWidget_GetPageTitle, ReturnValue) == 0x000000, "Member 'PhxAllocationTrackerWidget_GetPageTitle::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.GetXMaxLabel
// 0x0018 (0x0018 - 0x0000)
struct PhxAllocationTrackerWidget_GetXMaxLabel final
{
public:
	int32                                         GraphIndex;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_GetXMaxLabel) == 0x000008, "Wrong alignment on PhxAllocationTrackerWidget_GetXMaxLabel");
static_assert(sizeof(PhxAllocationTrackerWidget_GetXMaxLabel) == 0x000018, "Wrong size on PhxAllocationTrackerWidget_GetXMaxLabel");
static_assert(offsetof(PhxAllocationTrackerWidget_GetXMaxLabel, GraphIndex) == 0x000000, "Member 'PhxAllocationTrackerWidget_GetXMaxLabel::GraphIndex' has a wrong offset!");
static_assert(offsetof(PhxAllocationTrackerWidget_GetXMaxLabel, ReturnValue) == 0x000008, "Member 'PhxAllocationTrackerWidget_GetXMaxLabel::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.GetXMinLabel
// 0x0018 (0x0018 - 0x0000)
struct PhxAllocationTrackerWidget_GetXMinLabel final
{
public:
	int32                                         GraphIndex;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_GetXMinLabel) == 0x000008, "Wrong alignment on PhxAllocationTrackerWidget_GetXMinLabel");
static_assert(sizeof(PhxAllocationTrackerWidget_GetXMinLabel) == 0x000018, "Wrong size on PhxAllocationTrackerWidget_GetXMinLabel");
static_assert(offsetof(PhxAllocationTrackerWidget_GetXMinLabel, GraphIndex) == 0x000000, "Member 'PhxAllocationTrackerWidget_GetXMinLabel::GraphIndex' has a wrong offset!");
static_assert(offsetof(PhxAllocationTrackerWidget_GetXMinLabel, ReturnValue) == 0x000008, "Member 'PhxAllocationTrackerWidget_GetXMinLabel::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.GetYCurrentLabel
// 0x0018 (0x0018 - 0x0000)
struct PhxAllocationTrackerWidget_GetYCurrentLabel final
{
public:
	int32                                         GraphIndex;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_GetYCurrentLabel) == 0x000008, "Wrong alignment on PhxAllocationTrackerWidget_GetYCurrentLabel");
static_assert(sizeof(PhxAllocationTrackerWidget_GetYCurrentLabel) == 0x000018, "Wrong size on PhxAllocationTrackerWidget_GetYCurrentLabel");
static_assert(offsetof(PhxAllocationTrackerWidget_GetYCurrentLabel, GraphIndex) == 0x000000, "Member 'PhxAllocationTrackerWidget_GetYCurrentLabel::GraphIndex' has a wrong offset!");
static_assert(offsetof(PhxAllocationTrackerWidget_GetYCurrentLabel, ReturnValue) == 0x000008, "Member 'PhxAllocationTrackerWidget_GetYCurrentLabel::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.GetYMaxLabel
// 0x0018 (0x0018 - 0x0000)
struct PhxAllocationTrackerWidget_GetYMaxLabel final
{
public:
	int32                                         GraphIndex;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_GetYMaxLabel) == 0x000008, "Wrong alignment on PhxAllocationTrackerWidget_GetYMaxLabel");
static_assert(sizeof(PhxAllocationTrackerWidget_GetYMaxLabel) == 0x000018, "Wrong size on PhxAllocationTrackerWidget_GetYMaxLabel");
static_assert(offsetof(PhxAllocationTrackerWidget_GetYMaxLabel, GraphIndex) == 0x000000, "Member 'PhxAllocationTrackerWidget_GetYMaxLabel::GraphIndex' has a wrong offset!");
static_assert(offsetof(PhxAllocationTrackerWidget_GetYMaxLabel, ReturnValue) == 0x000008, "Member 'PhxAllocationTrackerWidget_GetYMaxLabel::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.GetYMinLabel
// 0x0018 (0x0018 - 0x0000)
struct PhxAllocationTrackerWidget_GetYMinLabel final
{
public:
	int32                                         GraphIndex;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_GetYMinLabel) == 0x000008, "Wrong alignment on PhxAllocationTrackerWidget_GetYMinLabel");
static_assert(sizeof(PhxAllocationTrackerWidget_GetYMinLabel) == 0x000018, "Wrong size on PhxAllocationTrackerWidget_GetYMinLabel");
static_assert(offsetof(PhxAllocationTrackerWidget_GetYMinLabel, GraphIndex) == 0x000000, "Member 'PhxAllocationTrackerWidget_GetYMinLabel::GraphIndex' has a wrong offset!");
static_assert(offsetof(PhxAllocationTrackerWidget_GetYMinLabel, ReturnValue) == 0x000008, "Member 'PhxAllocationTrackerWidget_GetYMinLabel::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.IncrementPageColumn
// 0x0004 (0x0004 - 0x0000)
struct PhxAllocationTrackerWidget_IncrementPageColumn final
{
public:
	int32                                         Amount;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_IncrementPageColumn) == 0x000004, "Wrong alignment on PhxAllocationTrackerWidget_IncrementPageColumn");
static_assert(sizeof(PhxAllocationTrackerWidget_IncrementPageColumn) == 0x000004, "Wrong size on PhxAllocationTrackerWidget_IncrementPageColumn");
static_assert(offsetof(PhxAllocationTrackerWidget_IncrementPageColumn, Amount) == 0x000000, "Member 'PhxAllocationTrackerWidget_IncrementPageColumn::Amount' has a wrong offset!");

// Function Phoenix.PhxAllocationTrackerWidget.IncrementPageRow
// 0x0004 (0x0004 - 0x0000)
struct PhxAllocationTrackerWidget_IncrementPageRow final
{
public:
	int32                                         Amount;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAllocationTrackerWidget_IncrementPageRow) == 0x000004, "Wrong alignment on PhxAllocationTrackerWidget_IncrementPageRow");
static_assert(sizeof(PhxAllocationTrackerWidget_IncrementPageRow) == 0x000004, "Wrong size on PhxAllocationTrackerWidget_IncrementPageRow");
static_assert(offsetof(PhxAllocationTrackerWidget_IncrementPageRow, Amount) == 0x000000, "Member 'PhxAllocationTrackerWidget_IncrementPageRow::Amount' has a wrong offset!");

// Function Phoenix.PhxAmmoComponent.UpdateAmmoDisplay
// 0x0004 (0x0004 - 0x0000)
struct PhxAmmoComponent_UpdateAmmoDisplay final
{
public:
	int32                                         ClipSize;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAmmoComponent_UpdateAmmoDisplay) == 0x000004, "Wrong alignment on PhxAmmoComponent_UpdateAmmoDisplay");
static_assert(sizeof(PhxAmmoComponent_UpdateAmmoDisplay) == 0x000004, "Wrong size on PhxAmmoComponent_UpdateAmmoDisplay");
static_assert(offsetof(PhxAmmoComponent_UpdateAmmoDisplay, ClipSize) == 0x000000, "Member 'PhxAmmoComponent_UpdateAmmoDisplay::ClipSize' has a wrong offset!");

// Function Phoenix.PhxAmmoComponent.GetAmmoInventoryName
// 0x0008 (0x0008 - 0x0000)
struct PhxAmmoComponent_GetAmmoInventoryName final
{
public:
	class FName                                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAmmoComponent_GetAmmoInventoryName) == 0x000004, "Wrong alignment on PhxAmmoComponent_GetAmmoInventoryName");
static_assert(sizeof(PhxAmmoComponent_GetAmmoInventoryName) == 0x000008, "Wrong size on PhxAmmoComponent_GetAmmoInventoryName");
static_assert(offsetof(PhxAmmoComponent_GetAmmoInventoryName, ReturnValue) == 0x000000, "Member 'PhxAmmoComponent_GetAmmoInventoryName::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAmmoComponent.GetCurrentAmmoInClip
// 0x0004 (0x0004 - 0x0000)
struct PhxAmmoComponent_GetCurrentAmmoInClip final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAmmoComponent_GetCurrentAmmoInClip) == 0x000004, "Wrong alignment on PhxAmmoComponent_GetCurrentAmmoInClip");
static_assert(sizeof(PhxAmmoComponent_GetCurrentAmmoInClip) == 0x000004, "Wrong size on PhxAmmoComponent_GetCurrentAmmoInClip");
static_assert(offsetof(PhxAmmoComponent_GetCurrentAmmoInClip, ReturnValue) == 0x000000, "Member 'PhxAmmoComponent_GetCurrentAmmoInClip::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAmmoComponent.GetCurrentAmmoInReserve
// 0x0004 (0x0004 - 0x0000)
struct PhxAmmoComponent_GetCurrentAmmoInReserve final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAmmoComponent_GetCurrentAmmoInReserve) == 0x000004, "Wrong alignment on PhxAmmoComponent_GetCurrentAmmoInReserve");
static_assert(sizeof(PhxAmmoComponent_GetCurrentAmmoInReserve) == 0x000004, "Wrong size on PhxAmmoComponent_GetCurrentAmmoInReserve");
static_assert(offsetof(PhxAmmoComponent_GetCurrentAmmoInReserve, ReturnValue) == 0x000000, "Member 'PhxAmmoComponent_GetCurrentAmmoInReserve::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAmmoComponent.GetTotalRemainingAmmo
// 0x0004 (0x0004 - 0x0000)
struct PhxAmmoComponent_GetTotalRemainingAmmo final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAmmoComponent_GetTotalRemainingAmmo) == 0x000004, "Wrong alignment on PhxAmmoComponent_GetTotalRemainingAmmo");
static_assert(sizeof(PhxAmmoComponent_GetTotalRemainingAmmo) == 0x000004, "Wrong size on PhxAmmoComponent_GetTotalRemainingAmmo");
static_assert(offsetof(PhxAmmoComponent_GetTotalRemainingAmmo, ReturnValue) == 0x000000, "Member 'PhxAmmoComponent_GetTotalRemainingAmmo::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifySettings.Get
// 0x0008 (0x0008 - 0x0000)
struct PhxSoundAnimNotifySettings_Get final
{
public:
	class UPhxSoundAnimNotifySettingsData*        ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundAnimNotifySettings_Get) == 0x000008, "Wrong alignment on PhxSoundAnimNotifySettings_Get");
static_assert(sizeof(PhxSoundAnimNotifySettings_Get) == 0x000008, "Wrong size on PhxSoundAnimNotifySettings_Get");
static_assert(offsetof(PhxSoundAnimNotifySettings_Get, ReturnValue) == 0x000000, "Member 'PhxSoundAnimNotifySettings_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundEndOfEventProxy.PlaySoundAndContinue
// 0x0030 (0x0030 - 0x0000)
struct PhxSoundEndOfEventProxy_PlaySoundAndContinue final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESoundSource                                  Source;                                            // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxSoundComponent*                     SoundComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkAudioEvent*                          Event;                                             // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AdditionalDelay;                                   // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxSoundEndOfEventProxy*               ReturnValue;                                       // 0x0028(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundEndOfEventProxy_PlaySoundAndContinue) == 0x000008, "Wrong alignment on PhxSoundEndOfEventProxy_PlaySoundAndContinue");
static_assert(sizeof(PhxSoundEndOfEventProxy_PlaySoundAndContinue) == 0x000030, "Wrong size on PhxSoundEndOfEventProxy_PlaySoundAndContinue");
static_assert(offsetof(PhxSoundEndOfEventProxy_PlaySoundAndContinue, WorldContextObject) == 0x000000, "Member 'PhxSoundEndOfEventProxy_PlaySoundAndContinue::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxSoundEndOfEventProxy_PlaySoundAndContinue, Source) == 0x000008, "Member 'PhxSoundEndOfEventProxy_PlaySoundAndContinue::Source' has a wrong offset!");
static_assert(offsetof(PhxSoundEndOfEventProxy_PlaySoundAndContinue, SoundComp) == 0x000010, "Member 'PhxSoundEndOfEventProxy_PlaySoundAndContinue::SoundComp' has a wrong offset!");
static_assert(offsetof(PhxSoundEndOfEventProxy_PlaySoundAndContinue, Event) == 0x000018, "Member 'PhxSoundEndOfEventProxy_PlaySoundAndContinue::Event' has a wrong offset!");
static_assert(offsetof(PhxSoundEndOfEventProxy_PlaySoundAndContinue, AdditionalDelay) == 0x000020, "Member 'PhxSoundEndOfEventProxy_PlaySoundAndContinue::AdditionalDelay' has a wrong offset!");
static_assert(offsetof(PhxSoundEndOfEventProxy_PlaySoundAndContinue, ReturnValue) == 0x000028, "Member 'PhxSoundEndOfEventProxy_PlaySoundAndContinue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLiteWeaponSkinComponent.OnWeaponSkinChanged
// 0x0008 (0x0008 - 0x0000)
struct PhxLiteWeaponSkinComponent_OnWeaponSkinChanged final
{
public:
	struct FGameplayTag                           InWeaponTag;                                       // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLiteWeaponSkinComponent_OnWeaponSkinChanged) == 0x000004, "Wrong alignment on PhxLiteWeaponSkinComponent_OnWeaponSkinChanged");
static_assert(sizeof(PhxLiteWeaponSkinComponent_OnWeaponSkinChanged) == 0x000008, "Wrong size on PhxLiteWeaponSkinComponent_OnWeaponSkinChanged");
static_assert(offsetof(PhxLiteWeaponSkinComponent_OnWeaponSkinChanged, InWeaponTag) == 0x000000, "Member 'PhxLiteWeaponSkinComponent_OnWeaponSkinChanged::InWeaponTag' has a wrong offset!");

// Function Phoenix.PhxLookAtComponent.BeginTriggerLookAt
// 0x0008 (0x0008 - 0x0000)
struct PhxLookAtComponent_BeginTriggerLookAt final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLookAtComponent_BeginTriggerLookAt) == 0x000008, "Wrong alignment on PhxLookAtComponent_BeginTriggerLookAt");
static_assert(sizeof(PhxLookAtComponent_BeginTriggerLookAt) == 0x000008, "Wrong size on PhxLookAtComponent_BeginTriggerLookAt");
static_assert(offsetof(PhxLookAtComponent_BeginTriggerLookAt, Character) == 0x000000, "Member 'PhxLookAtComponent_BeginTriggerLookAt::Character' has a wrong offset!");

// Function Phoenix.PhxLookAtComponent.EndTriggerLookAt
// 0x0008 (0x0008 - 0x0000)
struct PhxLookAtComponent_EndTriggerLookAt final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLookAtComponent_EndTriggerLookAt) == 0x000008, "Wrong alignment on PhxLookAtComponent_EndTriggerLookAt");
static_assert(sizeof(PhxLookAtComponent_EndTriggerLookAt) == 0x000008, "Wrong size on PhxLookAtComponent_EndTriggerLookAt");
static_assert(offsetof(PhxLookAtComponent_EndTriggerLookAt, Character) == 0x000000, "Member 'PhxLookAtComponent_EndTriggerLookAt::Character' has a wrong offset!");

// Function Phoenix.PhxLookAtComponent.SetLookIntensity
// 0x0004 (0x0004 - 0x0000)
struct PhxLookAtComponent_SetLookIntensity final
{
public:
	float                                         Intensity;                                         // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLookAtComponent_SetLookIntensity) == 0x000004, "Wrong alignment on PhxLookAtComponent_SetLookIntensity");
static_assert(sizeof(PhxLookAtComponent_SetLookIntensity) == 0x000004, "Wrong size on PhxLookAtComponent_SetLookIntensity");
static_assert(offsetof(PhxLookAtComponent_SetLookIntensity, Intensity) == 0x000000, "Member 'PhxLookAtComponent_SetLookIntensity::Intensity' has a wrong offset!");

// Function Phoenix.PhxLootDropList.GetDropRateData
// 0x0008 (0x0008 - 0x0000)
struct PhxLootDropList_GetDropRateData final
{
public:
	class UDataTable*                             ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLootDropList_GetDropRateData) == 0x000008, "Wrong alignment on PhxLootDropList_GetDropRateData");
static_assert(sizeof(PhxLootDropList_GetDropRateData) == 0x000008, "Wrong size on PhxLootDropList_GetDropRateData");
static_assert(offsetof(PhxLootDropList_GetDropRateData, ReturnValue) == 0x000000, "Member 'PhxLootDropList_GetDropRateData::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAnimNotifyState_CheckEnvironmentalHazard.OnMoveBlockedBy
// 0x0090 (0x0090 - 0x0000)
struct PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy final
{
public:
	class APhxAICharacter*                        Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Impact;                                            // 0x0008(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy) == 0x000008, "Wrong alignment on PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy");
static_assert(sizeof(PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy) == 0x000090, "Wrong size on PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy");
static_assert(offsetof(PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy, Character) == 0x000000, "Member 'PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy::Character' has a wrong offset!");
static_assert(offsetof(PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy, Impact) == 0x000008, "Member 'PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy::Impact' has a wrong offset!");

// Function Phoenix.PhxAnimNotifyState_PlaySound.OnAnimsPaused
// 0x0008 (0x0008 - 0x0000)
struct PhxAnimNotifyState_PlaySound_OnAnimsPaused final
{
public:
	class UPhxSkeletalMeshComponent*              MeshComp;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAnimNotifyState_PlaySound_OnAnimsPaused) == 0x000008, "Wrong alignment on PhxAnimNotifyState_PlaySound_OnAnimsPaused");
static_assert(sizeof(PhxAnimNotifyState_PlaySound_OnAnimsPaused) == 0x000008, "Wrong size on PhxAnimNotifyState_PlaySound_OnAnimsPaused");
static_assert(offsetof(PhxAnimNotifyState_PlaySound_OnAnimsPaused, MeshComp) == 0x000000, "Member 'PhxAnimNotifyState_PlaySound_OnAnimsPaused::MeshComp' has a wrong offset!");

// Function Phoenix.PhxAnimNotifyState_PlaySound.OnSoundEnded
// 0x0010 (0x0010 - 0x0000)
struct PhxAnimNotifyState_PlaySound_OnSoundEnded final
{
public:
	EAkCallbackType                               CallbackType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UAkCallbackInfo*                        CallbackInfo;                                      // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAnimNotifyState_PlaySound_OnSoundEnded) == 0x000008, "Wrong alignment on PhxAnimNotifyState_PlaySound_OnSoundEnded");
static_assert(sizeof(PhxAnimNotifyState_PlaySound_OnSoundEnded) == 0x000010, "Wrong size on PhxAnimNotifyState_PlaySound_OnSoundEnded");
static_assert(offsetof(PhxAnimNotifyState_PlaySound_OnSoundEnded, CallbackType) == 0x000000, "Member 'PhxAnimNotifyState_PlaySound_OnSoundEnded::CallbackType' has a wrong offset!");
static_assert(offsetof(PhxAnimNotifyState_PlaySound_OnSoundEnded, CallbackInfo) == 0x000008, "Member 'PhxAnimNotifyState_PlaySound_OnSoundEnded::CallbackInfo' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxAssetBudgetMeterManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxAssetBudgetMeterManager*            ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterManager_Get) == 0x000008, "Wrong alignment on PhxAssetBudgetMeterManager_Get");
static_assert(sizeof(PhxAssetBudgetMeterManager_Get) == 0x000010, "Wrong size on PhxAssetBudgetMeterManager_Get");
static_assert(offsetof(PhxAssetBudgetMeterManager_Get, WorldContextObject) == 0x000000, "Member 'PhxAssetBudgetMeterManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAssetBudgetMeterManager_Get, ReturnValue) == 0x000008, "Member 'PhxAssetBudgetMeterManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterManager.SetAssetBudgetMeterDebugVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterManager_SetAssetBudgetMeterDebugVisibility final
{
public:
	ESlateVisibility                              Visibility;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterManager_SetAssetBudgetMeterDebugVisibility) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterManager_SetAssetBudgetMeterDebugVisibility");
static_assert(sizeof(PhxAssetBudgetMeterManager_SetAssetBudgetMeterDebugVisibility) == 0x000001, "Wrong size on PhxAssetBudgetMeterManager_SetAssetBudgetMeterDebugVisibility");
static_assert(offsetof(PhxAssetBudgetMeterManager_SetAssetBudgetMeterDebugVisibility, Visibility) == 0x000000, "Member 'PhxAssetBudgetMeterManager_SetAssetBudgetMeterDebugVisibility::Visibility' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterManager.SetAssetBudgetMeterVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterManager_SetAssetBudgetMeterVisibility final
{
public:
	ESlateVisibility                              Visibility;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterManager_SetAssetBudgetMeterVisibility) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterManager_SetAssetBudgetMeterVisibility");
static_assert(sizeof(PhxAssetBudgetMeterManager_SetAssetBudgetMeterVisibility) == 0x000001, "Wrong size on PhxAssetBudgetMeterManager_SetAssetBudgetMeterVisibility");
static_assert(offsetof(PhxAssetBudgetMeterManager_SetAssetBudgetMeterVisibility, Visibility) == 0x000000, "Member 'PhxAssetBudgetMeterManager_SetAssetBudgetMeterVisibility::Visibility' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterManager.SetBenchmarkMetrics
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterManager_SetBenchmarkMetrics final
{
public:
	bool                                          Enabled;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterManager_SetBenchmarkMetrics) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterManager_SetBenchmarkMetrics");
static_assert(sizeof(PhxAssetBudgetMeterManager_SetBenchmarkMetrics) == 0x000001, "Wrong size on PhxAssetBudgetMeterManager_SetBenchmarkMetrics");
static_assert(offsetof(PhxAssetBudgetMeterManager_SetBenchmarkMetrics, Enabled) == 0x000000, "Member 'PhxAssetBudgetMeterManager_SetBenchmarkMetrics::Enabled' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterManager.SetUseBenchmarkMetricsOnVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterManager_SetUseBenchmarkMetricsOnVisible final
{
public:
	bool                                          Enabled;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterManager_SetUseBenchmarkMetricsOnVisible) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterManager_SetUseBenchmarkMetricsOnVisible");
static_assert(sizeof(PhxAssetBudgetMeterManager_SetUseBenchmarkMetricsOnVisible) == 0x000001, "Wrong size on PhxAssetBudgetMeterManager_SetUseBenchmarkMetricsOnVisible");
static_assert(offsetof(PhxAssetBudgetMeterManager_SetUseBenchmarkMetricsOnVisible, Enabled) == 0x000000, "Member 'PhxAssetBudgetMeterManager_SetUseBenchmarkMetricsOnVisible::Enabled' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterManager.GetAssetBudgetMeterWidget
// 0x0008 (0x0008 - 0x0000)
struct PhxAssetBudgetMeterManager_GetAssetBudgetMeterWidget final
{
public:
	class UPhxAssetBudgetMeterWidget*             ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterManager_GetAssetBudgetMeterWidget) == 0x000008, "Wrong alignment on PhxAssetBudgetMeterManager_GetAssetBudgetMeterWidget");
static_assert(sizeof(PhxAssetBudgetMeterManager_GetAssetBudgetMeterWidget) == 0x000008, "Wrong size on PhxAssetBudgetMeterManager_GetAssetBudgetMeterWidget");
static_assert(offsetof(PhxAssetBudgetMeterManager_GetAssetBudgetMeterWidget, ReturnValue) == 0x000000, "Member 'PhxAssetBudgetMeterManager_GetAssetBudgetMeterWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterManager.IsAssetBudgetMeterDebugVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterManager_IsAssetBudgetMeterDebugVisible final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterManager_IsAssetBudgetMeterDebugVisible) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterManager_IsAssetBudgetMeterDebugVisible");
static_assert(sizeof(PhxAssetBudgetMeterManager_IsAssetBudgetMeterDebugVisible) == 0x000001, "Wrong size on PhxAssetBudgetMeterManager_IsAssetBudgetMeterDebugVisible");
static_assert(offsetof(PhxAssetBudgetMeterManager_IsAssetBudgetMeterDebugVisible, ReturnValue) == 0x000000, "Member 'PhxAssetBudgetMeterManager_IsAssetBudgetMeterDebugVisible::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterManager.IsAssetBudgetMeterVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterManager_IsAssetBudgetMeterVisible final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterManager_IsAssetBudgetMeterVisible) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterManager_IsAssetBudgetMeterVisible");
static_assert(sizeof(PhxAssetBudgetMeterManager_IsAssetBudgetMeterVisible) == 0x000001, "Wrong size on PhxAssetBudgetMeterManager_IsAssetBudgetMeterVisible");
static_assert(offsetof(PhxAssetBudgetMeterManager_IsAssetBudgetMeterVisible, ReturnValue) == 0x000000, "Member 'PhxAssetBudgetMeterManager_IsAssetBudgetMeterVisible::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterManager.IsUsingBenchmarkMetricsOnVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterManager_IsUsingBenchmarkMetricsOnVisible final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterManager_IsUsingBenchmarkMetricsOnVisible) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterManager_IsUsingBenchmarkMetricsOnVisible");
static_assert(sizeof(PhxAssetBudgetMeterManager_IsUsingBenchmarkMetricsOnVisible) == 0x000001, "Wrong size on PhxAssetBudgetMeterManager_IsUsingBenchmarkMetricsOnVisible");
static_assert(offsetof(PhxAssetBudgetMeterManager_IsUsingBenchmarkMetricsOnVisible, ReturnValue) == 0x000000, "Member 'PhxAssetBudgetMeterManager_IsUsingBenchmarkMetricsOnVisible::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterWidget.AddGroupWidget
// 0x0008 (0x0008 - 0x0000)
struct PhxAssetBudgetMeterWidget_AddGroupWidget final
{
public:
	class UPhxAssetBudgetGroupWidget*             Widget;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterWidget_AddGroupWidget) == 0x000008, "Wrong alignment on PhxAssetBudgetMeterWidget_AddGroupWidget");
static_assert(sizeof(PhxAssetBudgetMeterWidget_AddGroupWidget) == 0x000008, "Wrong size on PhxAssetBudgetMeterWidget_AddGroupWidget");
static_assert(offsetof(PhxAssetBudgetMeterWidget_AddGroupWidget, Widget) == 0x000000, "Member 'PhxAssetBudgetMeterWidget_AddGroupWidget::Widget' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterWidget.AddSubGroupWidgets
// 0x0018 (0x0018 - 0x0000)
struct PhxAssetBudgetMeterWidget_AddSubGroupWidgets final
{
public:
	EPhxAssetBudgetGroup                          StatGroup;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UPhxAssetBudgetGroupWidget*>     SubWidgets;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterWidget_AddSubGroupWidgets) == 0x000008, "Wrong alignment on PhxAssetBudgetMeterWidget_AddSubGroupWidgets");
static_assert(sizeof(PhxAssetBudgetMeterWidget_AddSubGroupWidgets) == 0x000018, "Wrong size on PhxAssetBudgetMeterWidget_AddSubGroupWidgets");
static_assert(offsetof(PhxAssetBudgetMeterWidget_AddSubGroupWidgets, StatGroup) == 0x000000, "Member 'PhxAssetBudgetMeterWidget_AddSubGroupWidgets::StatGroup' has a wrong offset!");
static_assert(offsetof(PhxAssetBudgetMeterWidget_AddSubGroupWidgets, SubWidgets) == 0x000008, "Member 'PhxAssetBudgetMeterWidget_AddSubGroupWidgets::SubWidgets' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterWidget.IsDebugSectionVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterWidget_IsDebugSectionVisible final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterWidget_IsDebugSectionVisible) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterWidget_IsDebugSectionVisible");
static_assert(sizeof(PhxAssetBudgetMeterWidget_IsDebugSectionVisible) == 0x000001, "Wrong size on PhxAssetBudgetMeterWidget_IsDebugSectionVisible");
static_assert(offsetof(PhxAssetBudgetMeterWidget_IsDebugSectionVisible, ReturnValue) == 0x000000, "Member 'PhxAssetBudgetMeterWidget_IsDebugSectionVisible::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterWidget.SetDebugSectionVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterWidget_SetDebugSectionVisibility final
{
public:
	ESlateVisibility                              Vis;                                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterWidget_SetDebugSectionVisibility) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterWidget_SetDebugSectionVisibility");
static_assert(sizeof(PhxAssetBudgetMeterWidget_SetDebugSectionVisibility) == 0x000001, "Wrong size on PhxAssetBudgetMeterWidget_SetDebugSectionVisibility");
static_assert(offsetof(PhxAssetBudgetMeterWidget_SetDebugSectionVisibility, Vis) == 0x000000, "Member 'PhxAssetBudgetMeterWidget_SetDebugSectionVisibility::Vis' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterWidget.SetDetailTimingVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterWidget_SetDetailTimingVisibility final
{
public:
	ESlateVisibility                              Vis;                                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterWidget_SetDetailTimingVisibility) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterWidget_SetDetailTimingVisibility");
static_assert(sizeof(PhxAssetBudgetMeterWidget_SetDetailTimingVisibility) == 0x000001, "Wrong size on PhxAssetBudgetMeterWidget_SetDetailTimingVisibility");
static_assert(offsetof(PhxAssetBudgetMeterWidget_SetDetailTimingVisibility, Vis) == 0x000000, "Member 'PhxAssetBudgetMeterWidget_SetDetailTimingVisibility::Vis' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterWidget.SetDrawsStatsVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterWidget_SetDrawsStatsVisibility final
{
public:
	ESlateVisibility                              Vis;                                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterWidget_SetDrawsStatsVisibility) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterWidget_SetDrawsStatsVisibility");
static_assert(sizeof(PhxAssetBudgetMeterWidget_SetDrawsStatsVisibility) == 0x000001, "Wrong size on PhxAssetBudgetMeterWidget_SetDrawsStatsVisibility");
static_assert(offsetof(PhxAssetBudgetMeterWidget_SetDrawsStatsVisibility, Vis) == 0x000000, "Member 'PhxAssetBudgetMeterWidget_SetDrawsStatsVisibility::Vis' has a wrong offset!");

// Function Phoenix.PhxAssetBudgetMeterWidget.SetSubGroupsVisibility
// 0x0001 (0x0001 - 0x0000)
struct PhxAssetBudgetMeterWidget_SetSubGroupsVisibility final
{
public:
	bool                                          Visible;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAssetBudgetMeterWidget_SetSubGroupsVisibility) == 0x000001, "Wrong alignment on PhxAssetBudgetMeterWidget_SetSubGroupsVisibility");
static_assert(sizeof(PhxAssetBudgetMeterWidget_SetSubGroupsVisibility) == 0x000001, "Wrong size on PhxAssetBudgetMeterWidget_SetSubGroupsVisibility");
static_assert(offsetof(PhxAssetBudgetMeterWidget_SetSubGroupsVisibility, Visible) == 0x000000, "Member 'PhxAssetBudgetMeterWidget_SetSubGroupsVisibility::Visible' has a wrong offset!");

// Function Phoenix.PhxAudioPhysicsManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxAudioPhysicsManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAudioPhysicsManager*                ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxAudioPhysicsManager_Get) == 0x000008, "Wrong alignment on PhxAudioPhysicsManager_Get");
static_assert(sizeof(PhxAudioPhysicsManager_Get) == 0x000010, "Wrong size on PhxAudioPhysicsManager_Get");
static_assert(offsetof(PhxAudioPhysicsManager_Get, WorldContextObject) == 0x000000, "Member 'PhxAudioPhysicsManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxAudioPhysicsManager_Get, ReturnValue) == 0x000008, "Member 'PhxAudioPhysicsManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMuckVolume.OnVolumeBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxMuckVolume_OnVolumeBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMuckVolume_OnVolumeBeginOverlap) == 0x000008, "Wrong alignment on PhxMuckVolume_OnVolumeBeginOverlap");
static_assert(sizeof(PhxMuckVolume_OnVolumeBeginOverlap) == 0x0000A8, "Wrong size on PhxMuckVolume_OnVolumeBeginOverlap");
static_assert(offsetof(PhxMuckVolume_OnVolumeBeginOverlap, OverlappedComponent) == 0x000000, "Member 'PhxMuckVolume_OnVolumeBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxMuckVolume_OnVolumeBeginOverlap, OtherActor) == 0x000008, "Member 'PhxMuckVolume_OnVolumeBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxMuckVolume_OnVolumeBeginOverlap, OtherComp) == 0x000010, "Member 'PhxMuckVolume_OnVolumeBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxMuckVolume_OnVolumeBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxMuckVolume_OnVolumeBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxMuckVolume_OnVolumeBeginOverlap, bFromSweep) == 0x00001C, "Member 'PhxMuckVolume_OnVolumeBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxMuckVolume_OnVolumeBeginOverlap, SweepResult) == 0x000020, "Member 'PhxMuckVolume_OnVolumeBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxMuckVolume.OnVolumeEndOverlap
// 0x0020 (0x0020 - 0x0000)
struct PhxMuckVolume_OnVolumeEndOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxMuckVolume_OnVolumeEndOverlap) == 0x000008, "Wrong alignment on PhxMuckVolume_OnVolumeEndOverlap");
static_assert(sizeof(PhxMuckVolume_OnVolumeEndOverlap) == 0x000020, "Wrong size on PhxMuckVolume_OnVolumeEndOverlap");
static_assert(offsetof(PhxMuckVolume_OnVolumeEndOverlap, OverlappedComponent) == 0x000000, "Member 'PhxMuckVolume_OnVolumeEndOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxMuckVolume_OnVolumeEndOverlap, OtherActor) == 0x000008, "Member 'PhxMuckVolume_OnVolumeEndOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxMuckVolume_OnVolumeEndOverlap, OtherComp) == 0x000010, "Member 'PhxMuckVolume_OnVolumeEndOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxMuckVolume_OnVolumeEndOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxMuckVolume_OnVolumeEndOverlap::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PhxBio.IsDecrypted
// 0x0001 (0x0001 - 0x0000)
struct PhxBio_IsDecrypted final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBio_IsDecrypted) == 0x000001, "Wrong alignment on PhxBio_IsDecrypted");
static_assert(sizeof(PhxBio_IsDecrypted) == 0x000001, "Wrong size on PhxBio_IsDecrypted");
static_assert(offsetof(PhxBio_IsDecrypted, ReturnValue) == 0x000000, "Member 'PhxBio_IsDecrypted::ReturnValue' has a wrong offset!");

// Function Phoenix.SplineInteraction.DidEnterInReverse
// 0x0002 (0x0002 - 0x0000)
struct SplineInteraction_DidEnterInReverse final
{
public:
	EAxis                                         SplineAxis;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0001(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SplineInteraction_DidEnterInReverse) == 0x000001, "Wrong alignment on SplineInteraction_DidEnterInReverse");
static_assert(sizeof(SplineInteraction_DidEnterInReverse) == 0x000002, "Wrong size on SplineInteraction_DidEnterInReverse");
static_assert(offsetof(SplineInteraction_DidEnterInReverse, SplineAxis) == 0x000000, "Member 'SplineInteraction_DidEnterInReverse::SplineAxis' has a wrong offset!");
static_assert(offsetof(SplineInteraction_DidEnterInReverse, ReturnValue) == 0x000001, "Member 'SplineInteraction_DidEnterInReverse::ReturnValue' has a wrong offset!");

// Function Phoenix.SplineInteraction.GetInteractedComponent
// 0x0008 (0x0008 - 0x0000)
struct SplineInteraction_GetInteractedComponent final
{
public:
	class UInteractableComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SplineInteraction_GetInteractedComponent) == 0x000008, "Wrong alignment on SplineInteraction_GetInteractedComponent");
static_assert(sizeof(SplineInteraction_GetInteractedComponent) == 0x000008, "Wrong size on SplineInteraction_GetInteractedComponent");
static_assert(offsetof(SplineInteraction_GetInteractedComponent, ReturnValue) == 0x000000, "Member 'SplineInteraction_GetInteractedComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGraphicSettingsListManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxGraphicSettingsListManager_Get final
{
public:
	const class UObject*                          WorldContext;                                      // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxGraphicSettingsListManager*         ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGraphicSettingsListManager_Get) == 0x000008, "Wrong alignment on PhxGraphicSettingsListManager_Get");
static_assert(sizeof(PhxGraphicSettingsListManager_Get) == 0x000010, "Wrong size on PhxGraphicSettingsListManager_Get");
static_assert(offsetof(PhxGraphicSettingsListManager_Get, WorldContext) == 0x000000, "Member 'PhxGraphicSettingsListManager_Get::WorldContext' has a wrong offset!");
static_assert(offsetof(PhxGraphicSettingsListManager_Get, ReturnValue) == 0x000008, "Member 'PhxGraphicSettingsListManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGraphicSettingsListManager.IsVisible
// 0x0001 (0x0001 - 0x0000)
struct PhxGraphicSettingsListManager_IsVisible final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGraphicSettingsListManager_IsVisible) == 0x000001, "Wrong alignment on PhxGraphicSettingsListManager_IsVisible");
static_assert(sizeof(PhxGraphicSettingsListManager_IsVisible) == 0x000001, "Wrong size on PhxGraphicSettingsListManager_IsVisible");
static_assert(offsetof(PhxGraphicSettingsListManager_IsVisible, ReturnValue) == 0x000000, "Member 'PhxGraphicSettingsListManager_IsVisible::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxBlueprintAction_LoadScriptedEventCinematics.LoadScriptedEventCinematics
// 0x0010 (0x0010 - 0x0000)
struct PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics final
{
public:
	class APhxScriptedEventActor*                 ScriptedEventActor;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxBlueprintAction_LoadScriptedEventCinematics* ReturnValue;                              // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics) == 0x000008, "Wrong alignment on PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics");
static_assert(sizeof(PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics) == 0x000010, "Wrong size on PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics");
static_assert(offsetof(PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics, ScriptedEventActor) == 0x000000, "Member 'PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics::ScriptedEventActor' has a wrong offset!");
static_assert(offsetof(PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics, ReturnValue) == 0x000008, "Member 'PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxBlueprintAction_MovementSpline_AlignToLocation.AlignLocationOffsetToWorldLocation
// 0x0020 (0x0020 - 0x0000)
struct PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation final
{
public:
	class APhxMovementSpline*                     MovementSpline;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                Location;                                          // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxBlueprintAction_MovementSpline_AlignToLocation* ReturnValue;                           // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation) == 0x000008, "Wrong alignment on PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation");
static_assert(sizeof(PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation) == 0x000020, "Wrong size on PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation");
static_assert(offsetof(PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation, MovementSpline) == 0x000000, "Member 'PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation::MovementSpline' has a wrong offset!");
static_assert(offsetof(PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation, Location) == 0x000008, "Member 'PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation::Location' has a wrong offset!");
static_assert(offsetof(PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation, ReturnValue) == 0x000018, "Member 'PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxBlueprintAction_SwapPlayerPawn.SwapPlayerPawn
// 0x0038 (0x0038 - 0x0000)
struct PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn final
{
public:
	class APlayerController*                      PlayerController;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSoftClassPtr<class UClass>                   NewCharacter;                                      // 0x0008(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxBlueprintAction_SwapPlayerPawn*     ReturnValue;                                       // 0x0030(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn) == 0x000008, "Wrong alignment on PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn");
static_assert(sizeof(PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn) == 0x000038, "Wrong size on PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn");
static_assert(offsetof(PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn, PlayerController) == 0x000000, "Member 'PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn::PlayerController' has a wrong offset!");
static_assert(offsetof(PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn, NewCharacter) == 0x000008, "Member 'PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn::NewCharacter' has a wrong offset!");
static_assert(offsetof(PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn, ReturnValue) == 0x000030, "Member 'PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGrinderLocomotionComponent.InitializeGrinderLocomotion
// 0x0010 (0x0010 - 0x0000)
struct PhxGrinderLocomotionComponent_InitializeGrinderLocomotion final
{
public:
	TArray<struct FRotatingGear>                  RotatingGears;                                     // 0x0000(0x0010)(Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGrinderLocomotionComponent_InitializeGrinderLocomotion) == 0x000008, "Wrong alignment on PhxGrinderLocomotionComponent_InitializeGrinderLocomotion");
static_assert(sizeof(PhxGrinderLocomotionComponent_InitializeGrinderLocomotion) == 0x000010, "Wrong size on PhxGrinderLocomotionComponent_InitializeGrinderLocomotion");
static_assert(offsetof(PhxGrinderLocomotionComponent_InitializeGrinderLocomotion, RotatingGears) == 0x000000, "Member 'PhxGrinderLocomotionComponent_InitializeGrinderLocomotion::RotatingGears' has a wrong offset!");

// Function Phoenix.PhxLootProp.SpawnItem
// 0x0010 (0x0010 - 0x0000)
struct PhxLootProp_SpawnItem final
{
public:
	class APhxPlayerCharacter*                    Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSimulatePhysics;                                  // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLootProp_SpawnItem) == 0x000008, "Wrong alignment on PhxLootProp_SpawnItem");
static_assert(sizeof(PhxLootProp_SpawnItem) == 0x000010, "Wrong size on PhxLootProp_SpawnItem");
static_assert(offsetof(PhxLootProp_SpawnItem, Character) == 0x000000, "Member 'PhxLootProp_SpawnItem::Character' has a wrong offset!");
static_assert(offsetof(PhxLootProp_SpawnItem, bSimulatePhysics) == 0x000008, "Member 'PhxLootProp_SpawnItem::bSimulatePhysics' has a wrong offset!");

// Function Phoenix.PhxBreakableLootProp.BreakProp
// 0x0008 (0x0008 - 0x0000)
struct PhxBreakableLootProp_BreakProp final
{
public:
	class APhxPlayerCharacter*                    Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxBreakableLootProp_BreakProp) == 0x000008, "Wrong alignment on PhxBreakableLootProp_BreakProp");
static_assert(sizeof(PhxBreakableLootProp_BreakProp) == 0x000008, "Wrong size on PhxBreakableLootProp_BreakProp");
static_assert(offsetof(PhxBreakableLootProp_BreakProp, Character) == 0x000000, "Member 'PhxBreakableLootProp_BreakProp::Character' has a wrong offset!");

// Function Phoenix.PhxBreakableLootProp.TakeDamage
// 0x0030 (0x0030 - 0x0000)
struct PhxBreakableLootProp_TakeDamage final
{
public:
	float                                         Damage;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FDamageEvent                           DamageEvent;                                       // 0x0008(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class AController*                            EventInstigator;                                   // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0028(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxBreakableLootProp_TakeDamage) == 0x000008, "Wrong alignment on PhxBreakableLootProp_TakeDamage");
static_assert(sizeof(PhxBreakableLootProp_TakeDamage) == 0x000030, "Wrong size on PhxBreakableLootProp_TakeDamage");
static_assert(offsetof(PhxBreakableLootProp_TakeDamage, Damage) == 0x000000, "Member 'PhxBreakableLootProp_TakeDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxBreakableLootProp_TakeDamage, DamageEvent) == 0x000008, "Member 'PhxBreakableLootProp_TakeDamage::DamageEvent' has a wrong offset!");
static_assert(offsetof(PhxBreakableLootProp_TakeDamage, EventInstigator) == 0x000018, "Member 'PhxBreakableLootProp_TakeDamage::EventInstigator' has a wrong offset!");
static_assert(offsetof(PhxBreakableLootProp_TakeDamage, DamageCauser) == 0x000020, "Member 'PhxBreakableLootProp_TakeDamage::DamageCauser' has a wrong offset!");
static_assert(offsetof(PhxBreakableLootProp_TakeDamage, ReturnValue) == 0x000028, "Member 'PhxBreakableLootProp_TakeDamage::ReturnValue' has a wrong offset!");

// Function Phoenix.PuzzleTriggerableActor.OnTriggered_BP
// 0x0001 (0x0001 - 0x0000)
struct PuzzleTriggerableActor_OnTriggered_BP final
{
public:
	bool                                          bOn;                                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PuzzleTriggerableActor_OnTriggered_BP) == 0x000001, "Wrong alignment on PuzzleTriggerableActor_OnTriggered_BP");
static_assert(sizeof(PuzzleTriggerableActor_OnTriggered_BP) == 0x000001, "Wrong size on PuzzleTriggerableActor_OnTriggered_BP");
static_assert(offsetof(PuzzleTriggerableActor_OnTriggered_BP, bOn) == 0x000000, "Member 'PuzzleTriggerableActor_OnTriggered_BP::bOn' has a wrong offset!");

// Function Phoenix.WSInteractionWidget.GetControllerKey
// 0x0001 (0x0001 - 0x0000)
struct WSInteractionWidget_GetControllerKey final
{
public:
	EPhxControllerKeys                            ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInteractionWidget_GetControllerKey) == 0x000001, "Wrong alignment on WSInteractionWidget_GetControllerKey");
static_assert(sizeof(WSInteractionWidget_GetControllerKey) == 0x000001, "Wrong size on WSInteractionWidget_GetControllerKey");
static_assert(offsetof(WSInteractionWidget_GetControllerKey, ReturnValue) == 0x000000, "Member 'WSInteractionWidget_GetControllerKey::ReturnValue' has a wrong offset!");

// Function Phoenix.WSInteractionWidget.GetTextureFromTexturePack
// 0x0010 (0x0010 - 0x0000)
struct WSInteractionWidget_GetTextureFromTexturePack final
{
public:
	const class UPhxPlatformTexturePack*          TexturePack;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture*                               ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInteractionWidget_GetTextureFromTexturePack) == 0x000008, "Wrong alignment on WSInteractionWidget_GetTextureFromTexturePack");
static_assert(sizeof(WSInteractionWidget_GetTextureFromTexturePack) == 0x000010, "Wrong size on WSInteractionWidget_GetTextureFromTexturePack");
static_assert(offsetof(WSInteractionWidget_GetTextureFromTexturePack, TexturePack) == 0x000000, "Member 'WSInteractionWidget_GetTextureFromTexturePack::TexturePack' has a wrong offset!");
static_assert(offsetof(WSInteractionWidget_GetTextureFromTexturePack, ReturnValue) == 0x000008, "Member 'WSInteractionWidget_GetTextureFromTexturePack::ReturnValue' has a wrong offset!");

// Function Phoenix.WSInteractionWidget.NotifyBlockedChanged
// 0x0001 (0x0001 - 0x0000)
struct WSInteractionWidget_NotifyBlockedChanged final
{
public:
	bool                                          bIsBlocked;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInteractionWidget_NotifyBlockedChanged) == 0x000001, "Wrong alignment on WSInteractionWidget_NotifyBlockedChanged");
static_assert(sizeof(WSInteractionWidget_NotifyBlockedChanged) == 0x000001, "Wrong size on WSInteractionWidget_NotifyBlockedChanged");
static_assert(offsetof(WSInteractionWidget_NotifyBlockedChanged, bIsBlocked) == 0x000000, "Member 'WSInteractionWidget_NotifyBlockedChanged::bIsBlocked' has a wrong offset!");

// Function Phoenix.WSInteractionWidget.NotifyProximityChanged
// 0x0002 (0x0002 - 0x0000)
struct WSInteractionWidget_NotifyProximityChanged final
{
public:
	EInteractableProximity                        CurrentProximity;                                  // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInteractableProximity                        PreviousProximity;                                 // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInteractionWidget_NotifyProximityChanged) == 0x000001, "Wrong alignment on WSInteractionWidget_NotifyProximityChanged");
static_assert(sizeof(WSInteractionWidget_NotifyProximityChanged) == 0x000002, "Wrong size on WSInteractionWidget_NotifyProximityChanged");
static_assert(offsetof(WSInteractionWidget_NotifyProximityChanged, CurrentProximity) == 0x000000, "Member 'WSInteractionWidget_NotifyProximityChanged::CurrentProximity' has a wrong offset!");
static_assert(offsetof(WSInteractionWidget_NotifyProximityChanged, PreviousProximity) == 0x000001, "Member 'WSInteractionWidget_NotifyProximityChanged::PreviousProximity' has a wrong offset!");

// Function Phoenix.WSInteractionWidget.SetButtonPromptSize
// 0x0001 (0x0001 - 0x0000)
struct WSInteractionWidget_SetButtonPromptSize final
{
public:
	ESDSSize                                      NewSize;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInteractionWidget_SetButtonPromptSize) == 0x000001, "Wrong alignment on WSInteractionWidget_SetButtonPromptSize");
static_assert(sizeof(WSInteractionWidget_SetButtonPromptSize) == 0x000001, "Wrong size on WSInteractionWidget_SetButtonPromptSize");
static_assert(offsetof(WSInteractionWidget_SetButtonPromptSize, NewSize) == 0x000000, "Member 'WSInteractionWidget_SetButtonPromptSize::NewSize' has a wrong offset!");

// Function Phoenix.WSInteractionWidget.SetProgress
// 0x0004 (0x0004 - 0x0000)
struct WSInteractionWidget_SetProgress final
{
public:
	float                                         ProgressPercentage;                                // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInteractionWidget_SetProgress) == 0x000004, "Wrong alignment on WSInteractionWidget_SetProgress");
static_assert(sizeof(WSInteractionWidget_SetProgress) == 0x000004, "Wrong size on WSInteractionWidget_SetProgress");
static_assert(offsetof(WSInteractionWidget_SetProgress, ProgressPercentage) == 0x000000, "Member 'WSInteractionWidget_SetProgress::ProgressPercentage' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingTransitionVolume.HandleActorBeginOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap) == 0x000008, "Wrong alignment on PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap");
static_assert(sizeof(PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap) == 0x000010, "Wrong size on PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap");
static_assert(offsetof(PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap, OverlappedActor) == 0x000000, "Member 'PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap, OtherActor) == 0x000008, "Member 'PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingTransitionVolume.HandleActorEndOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelStreamingTransitionVolume_HandleActorEndOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelStreamingTransitionVolume_HandleActorEndOverlap) == 0x000008, "Wrong alignment on PhxLevelStreamingTransitionVolume_HandleActorEndOverlap");
static_assert(sizeof(PhxLevelStreamingTransitionVolume_HandleActorEndOverlap) == 0x000010, "Wrong size on PhxLevelStreamingTransitionVolume_HandleActorEndOverlap");
static_assert(offsetof(PhxLevelStreamingTransitionVolume_HandleActorEndOverlap, OverlappedActor) == 0x000000, "Member 'PhxLevelStreamingTransitionVolume_HandleActorEndOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingTransitionVolume_HandleActorEndOverlap, OtherActor) == 0x000008, "Member 'PhxLevelStreamingTransitionVolume_HandleActorEndOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingTransitionVolume.IsLocked
// 0x0001 (0x0001 - 0x0000)
struct PhxLevelStreamingTransitionVolume_IsLocked final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelStreamingTransitionVolume_IsLocked) == 0x000001, "Wrong alignment on PhxLevelStreamingTransitionVolume_IsLocked");
static_assert(sizeof(PhxLevelStreamingTransitionVolume_IsLocked) == 0x000001, "Wrong size on PhxLevelStreamingTransitionVolume_IsLocked");
static_assert(offsetof(PhxLevelStreamingTransitionVolume_IsLocked, ReturnValue) == 0x000000, "Member 'PhxLevelStreamingTransitionVolume_IsLocked::ReturnValue' has a wrong offset!");

// Function Phoenix.WSSelectable.NotifyActive
// 0x0001 (0x0001 - 0x0000)
struct WSSelectable_NotifyActive final
{
public:
	bool                                          bActive;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSelectable_NotifyActive) == 0x000001, "Wrong alignment on WSSelectable_NotifyActive");
static_assert(sizeof(WSSelectable_NotifyActive) == 0x000001, "Wrong size on WSSelectable_NotifyActive");
static_assert(offsetof(WSSelectable_NotifyActive, bActive) == 0x000000, "Member 'WSSelectable_NotifyActive::bActive' has a wrong offset!");

// Function Phoenix.WSSelectable.SetLocked
// 0x0001 (0x0001 - 0x0000)
struct WSSelectable_SetLocked final
{
public:
	bool                                          bInLocked;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSelectable_SetLocked) == 0x000001, "Wrong alignment on WSSelectable_SetLocked");
static_assert(sizeof(WSSelectable_SetLocked) == 0x000001, "Wrong size on WSSelectable_SetLocked");
static_assert(offsetof(WSSelectable_SetLocked, bInLocked) == 0x000000, "Member 'WSSelectable_SetLocked::bInLocked' has a wrong offset!");

// Function Phoenix.WSSelectable.SetSelected
// 0x0001 (0x0001 - 0x0000)
struct WSSelectable_SetSelected final
{
public:
	bool                                          bInSelected;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSelectable_SetSelected) == 0x000001, "Wrong alignment on WSSelectable_SetSelected");
static_assert(sizeof(WSSelectable_SetSelected) == 0x000001, "Wrong size on WSSelectable_SetSelected");
static_assert(offsetof(WSSelectable_SetSelected, bInSelected) == 0x000000, "Member 'WSSelectable_SetSelected::bInSelected' has a wrong offset!");

// Function Phoenix.WSSelectable.GetAdjacent
// 0x0010 (0x0010 - 0x0000)
struct WSSelectable_GetAdjacent final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class AWSSelectable*                          ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSelectable_GetAdjacent) == 0x000008, "Wrong alignment on WSSelectable_GetAdjacent");
static_assert(sizeof(WSSelectable_GetAdjacent) == 0x000010, "Wrong size on WSSelectable_GetAdjacent");
static_assert(offsetof(WSSelectable_GetAdjacent, Direction) == 0x000000, "Member 'WSSelectable_GetAdjacent::Direction' has a wrong offset!");
static_assert(offsetof(WSSelectable_GetAdjacent, ReturnValue) == 0x000008, "Member 'WSSelectable_GetAdjacent::ReturnValue' has a wrong offset!");

// Function Phoenix.WSSelectable.GetIsLocked
// 0x0001 (0x0001 - 0x0000)
struct WSSelectable_GetIsLocked final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSelectable_GetIsLocked) == 0x000001, "Wrong alignment on WSSelectable_GetIsLocked");
static_assert(sizeof(WSSelectable_GetIsLocked) == 0x000001, "Wrong size on WSSelectable_GetIsLocked");
static_assert(offsetof(WSSelectable_GetIsLocked, ReturnValue) == 0x000000, "Member 'WSSelectable_GetIsLocked::ReturnValue' has a wrong offset!");

// Function Phoenix.WSSelectable.GetIsSelected
// 0x0001 (0x0001 - 0x0000)
struct WSSelectable_GetIsSelected final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSelectable_GetIsSelected) == 0x000001, "Wrong alignment on WSSelectable_GetIsSelected");
static_assert(sizeof(WSSelectable_GetIsSelected) == 0x000001, "Wrong size on WSSelectable_GetIsSelected");
static_assert(offsetof(WSSelectable_GetIsSelected, ReturnValue) == 0x000000, "Member 'WSSelectable_GetIsSelected::ReturnValue' has a wrong offset!");

// Function Phoenix.WSSelectable.GetMenuReaderTag
// 0x0008 (0x0008 - 0x0000)
struct WSSelectable_GetMenuReaderTag final
{
public:
	class FName                                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSelectable_GetMenuReaderTag) == 0x000004, "Wrong alignment on WSSelectable_GetMenuReaderTag");
static_assert(sizeof(WSSelectable_GetMenuReaderTag) == 0x000008, "Wrong size on WSSelectable_GetMenuReaderTag");
static_assert(offsetof(WSSelectable_GetMenuReaderTag, ReturnValue) == 0x000000, "Member 'WSSelectable_GetMenuReaderTag::ReturnValue' has a wrong offset!");

// Function Phoenix.WSButton.SetLabel
// 0x0018 (0x0018 - 0x0000)
struct WSButton_SetLabel final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSButton_SetLabel) == 0x000008, "Wrong alignment on WSButton_SetLabel");
static_assert(sizeof(WSButton_SetLabel) == 0x000018, "Wrong size on WSButton_SetLabel");
static_assert(offsetof(WSButton_SetLabel, InText) == 0x000000, "Member 'WSButton_SetLabel::InText' has a wrong offset!");

// Function Phoenix.WSSkillTreeButton.ApplyVID
// 0x0008 (0x0008 - 0x0000)
struct WSSkillTreeButton_ApplyVID final
{
public:
	const class UVirtualItemData*                 InVID;                                             // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTreeButton_ApplyVID) == 0x000008, "Wrong alignment on WSSkillTreeButton_ApplyVID");
static_assert(sizeof(WSSkillTreeButton_ApplyVID) == 0x000008, "Wrong size on WSSkillTreeButton_ApplyVID");
static_assert(offsetof(WSSkillTreeButton_ApplyVID, InVID) == 0x000000, "Member 'WSSkillTreeButton_ApplyVID::InVID' has a wrong offset!");

// Function Phoenix.WSSkillTreeButton.SetItem
// 0x0100 (0x0100 - 0x0000)
struct WSSkillTreeButton_SetItem final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTreeButton_SetItem) == 0x000008, "Wrong alignment on WSSkillTreeButton_SetItem");
static_assert(sizeof(WSSkillTreeButton_SetItem) == 0x000100, "Wrong size on WSSkillTreeButton_SetItem");
static_assert(offsetof(WSSkillTreeButton_SetItem, InItem) == 0x000000, "Member 'WSSkillTreeButton_SetItem::InItem' has a wrong offset!");

// Function Phoenix.WSSkillTreeButton.SetOpacity
// 0x0004 (0x0004 - 0x0000)
struct WSSkillTreeButton_SetOpacity final
{
public:
	float                                         Opacity;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTreeButton_SetOpacity) == 0x000004, "Wrong alignment on WSSkillTreeButton_SetOpacity");
static_assert(sizeof(WSSkillTreeButton_SetOpacity) == 0x000004, "Wrong size on WSSkillTreeButton_SetOpacity");
static_assert(offsetof(WSSkillTreeButton_SetOpacity, Opacity) == 0x000000, "Member 'WSSkillTreeButton_SetOpacity::Opacity' has a wrong offset!");

// Function Phoenix.WSSkillTreeButton.GetCachedItemData
// 0x0100 (0x0100 - 0x0000)
struct WSSkillTreeButton_GetCachedItemData final
{
public:
	struct FItemData                              ReturnValue;                                       // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTreeButton_GetCachedItemData) == 0x000008, "Wrong alignment on WSSkillTreeButton_GetCachedItemData");
static_assert(sizeof(WSSkillTreeButton_GetCachedItemData) == 0x000100, "Wrong size on WSSkillTreeButton_GetCachedItemData");
static_assert(offsetof(WSSkillTreeButton_GetCachedItemData, ReturnValue) == 0x000000, "Member 'WSSkillTreeButton_GetCachedItemData::ReturnValue' has a wrong offset!");

// Function Phoenix.WSSkillTreeButton.GetItemRowHandle
// 0x0010 (0x0010 - 0x0000)
struct WSSkillTreeButton_GetItemRowHandle final
{
public:
	struct FDataTableRowHandle                    ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSkillTreeButton_GetItemRowHandle) == 0x000008, "Wrong alignment on WSSkillTreeButton_GetItemRowHandle");
static_assert(sizeof(WSSkillTreeButton_GetItemRowHandle) == 0x000010, "Wrong size on WSSkillTreeButton_GetItemRowHandle");
static_assert(offsetof(WSSkillTreeButton_GetItemRowHandle, ReturnValue) == 0x000000, "Member 'WSSkillTreeButton_GetItemRowHandle::ReturnValue' has a wrong offset!");

// Function Phoenix.WSAmmoButton.SetElementsVisibility
// 0x0001 (0x0001 - 0x0000)
struct WSAmmoButton_SetElementsVisibility final
{
public:
	bool                                          bVisible;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSAmmoButton_SetElementsVisibility) == 0x000001, "Wrong alignment on WSAmmoButton_SetElementsVisibility");
static_assert(sizeof(WSAmmoButton_SetElementsVisibility) == 0x000001, "Wrong size on WSAmmoButton_SetElementsVisibility");
static_assert(offsetof(WSAmmoButton_SetElementsVisibility, bVisible) == 0x000000, "Member 'WSAmmoButton_SetElementsVisibility::bVisible' has a wrong offset!");

// Function Phoenix.WSAmmoButton.GetNumStacks
// 0x0004 (0x0004 - 0x0000)
struct WSAmmoButton_GetNumStacks final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSAmmoButton_GetNumStacks) == 0x000004, "Wrong alignment on WSAmmoButton_GetNumStacks");
static_assert(sizeof(WSAmmoButton_GetNumStacks) == 0x000004, "Wrong size on WSAmmoButton_GetNumStacks");
static_assert(offsetof(WSAmmoButton_GetNumStacks, ReturnValue) == 0x000000, "Member 'WSAmmoButton_GetNumStacks::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLightFixture.InitializeLightFixture
// 0x0018 (0x0018 - 0x0000)
struct PhxLightFixture_InitializeLightFixture final
{
public:
	TArray<class ULightComponent*>                InLightComponents;                                 // 0x0000(0x0010)(Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLightFixture_InitializeLightFixture) == 0x000008, "Wrong alignment on PhxLightFixture_InitializeLightFixture");
static_assert(sizeof(PhxLightFixture_InitializeLightFixture) == 0x000018, "Wrong size on PhxLightFixture_InitializeLightFixture");
static_assert(offsetof(PhxLightFixture_InitializeLightFixture, InLightComponents) == 0x000000, "Member 'PhxLightFixture_InitializeLightFixture::InLightComponents' has a wrong offset!");
static_assert(offsetof(PhxLightFixture_InitializeLightFixture, ReturnValue) == 0x000010, "Member 'PhxLightFixture_InitializeLightFixture::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLightFixture.UpdateFlickerTimelineFunc
// 0x0004 (0x0004 - 0x0000)
struct PhxLightFixture_UpdateFlickerTimelineFunc final
{
public:
	float                                         OutputFlickerPattern;                              // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLightFixture_UpdateFlickerTimelineFunc) == 0x000004, "Wrong alignment on PhxLightFixture_UpdateFlickerTimelineFunc");
static_assert(sizeof(PhxLightFixture_UpdateFlickerTimelineFunc) == 0x000004, "Wrong size on PhxLightFixture_UpdateFlickerTimelineFunc");
static_assert(offsetof(PhxLightFixture_UpdateFlickerTimelineFunc, OutputFlickerPattern) == 0x000000, "Member 'PhxLightFixture_UpdateFlickerTimelineFunc::OutputFlickerPattern' has a wrong offset!");

// Function Phoenix.WSWidgetActor.GetWidgetObject
// 0x0008 (0x0008 - 0x0000)
struct WSWidgetActor_GetWidgetObject final
{
public:
	class UUserWidget*                            ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSWidgetActor_GetWidgetObject) == 0x000008, "Wrong alignment on WSWidgetActor_GetWidgetObject");
static_assert(sizeof(WSWidgetActor_GetWidgetObject) == 0x000008, "Wrong size on WSWidgetActor_GetWidgetObject");
static_assert(offsetof(WSWidgetActor_GetWidgetObject, ReturnValue) == 0x000000, "Member 'WSWidgetActor_GetWidgetObject::ReturnValue' has a wrong offset!");

// Function Phoenix.WSNotificationActor.PopNotification
// 0x0130 (0x0130 - 0x0000)
struct WSNotificationActor_PopNotification final
{
public:
	struct FNotificationData                      OutNotification;                                   // 0x0000(0x0128)(Parm, OutParm, NativeAccessSpecifierPublic)
	bool                                          OutIsValid;                                        // 0x0128(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_129[0x7];                                      // 0x0129(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WSNotificationActor_PopNotification) == 0x000008, "Wrong alignment on WSNotificationActor_PopNotification");
static_assert(sizeof(WSNotificationActor_PopNotification) == 0x000130, "Wrong size on WSNotificationActor_PopNotification");
static_assert(offsetof(WSNotificationActor_PopNotification, OutNotification) == 0x000000, "Member 'WSNotificationActor_PopNotification::OutNotification' has a wrong offset!");
static_assert(offsetof(WSNotificationActor_PopNotification, OutIsValid) == 0x000128, "Member 'WSNotificationActor_PopNotification::OutIsValid' has a wrong offset!");

// Function Phoenix.WSNotificationActor.SetPlaying
// 0x0008 (0x0008 - 0x0000)
struct WSNotificationActor_SetPlaying final
{
public:
	const class UAudioLogVirtualData*             InAudioVID;                                        // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSNotificationActor_SetPlaying) == 0x000008, "Wrong alignment on WSNotificationActor_SetPlaying");
static_assert(sizeof(WSNotificationActor_SetPlaying) == 0x000008, "Wrong size on WSNotificationActor_SetPlaying");
static_assert(offsetof(WSNotificationActor_SetPlaying, InAudioVID) == 0x000000, "Member 'WSNotificationActor_SetPlaying::InAudioVID' has a wrong offset!");

// Function Phoenix.WSNotificationActor.SetQuickSwapUIVisible
// 0x0001 (0x0001 - 0x0000)
struct WSNotificationActor_SetQuickSwapUIVisible final
{
public:
	bool                                          bVisible;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSNotificationActor_SetQuickSwapUIVisible) == 0x000001, "Wrong alignment on WSNotificationActor_SetQuickSwapUIVisible");
static_assert(sizeof(WSNotificationActor_SetQuickSwapUIVisible) == 0x000001, "Wrong size on WSNotificationActor_SetQuickSwapUIVisible");
static_assert(offsetof(WSNotificationActor_SetQuickSwapUIVisible, bVisible) == 0x000000, "Member 'WSNotificationActor_SetQuickSwapUIVisible::bVisible' has a wrong offset!");

// Function Phoenix.WSNotificationActor.GetQuickSwapUI
// 0x0008 (0x0008 - 0x0000)
struct WSNotificationActor_GetQuickSwapUI final
{
public:
	class USDSScreenWidget*                       ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSNotificationActor_GetQuickSwapUI) == 0x000008, "Wrong alignment on WSNotificationActor_GetQuickSwapUI");
static_assert(sizeof(WSNotificationActor_GetQuickSwapUI) == 0x000008, "Wrong size on WSNotificationActor_GetQuickSwapUI");
static_assert(offsetof(WSNotificationActor_GetQuickSwapUI, ReturnValue) == 0x000000, "Member 'WSNotificationActor_GetQuickSwapUI::ReturnValue' has a wrong offset!");

// Function Phoenix.WSNotificationActor.HasNotificationQueued
// 0x0001 (0x0001 - 0x0000)
struct WSNotificationActor_HasNotificationQueued final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSNotificationActor_HasNotificationQueued) == 0x000001, "Wrong alignment on WSNotificationActor_HasNotificationQueued");
static_assert(sizeof(WSNotificationActor_HasNotificationQueued) == 0x000001, "Wrong size on WSNotificationActor_HasNotificationQueued");
static_assert(offsetof(WSNotificationActor_HasNotificationQueued, ReturnValue) == 0x000000, "Member 'WSNotificationActor_HasNotificationQueued::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanelUMG.GetUserWidget
// 0x0008 (0x0008 - 0x0000)
struct WSPanelUMG_GetUserWidget final
{
public:
	class UUserWidget*                            ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanelUMG_GetUserWidget) == 0x000008, "Wrong alignment on WSPanelUMG_GetUserWidget");
static_assert(sizeof(WSPanelUMG_GetUserWidget) == 0x000008, "Wrong size on WSPanelUMG_GetUserWidget");
static_assert(offsetof(WSPanelUMG_GetUserWidget, ReturnValue) == 0x000000, "Member 'WSPanelUMG_GetUserWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.WSPanelUMG.IsPlayingAnimation
// 0x0001 (0x0001 - 0x0000)
struct WSPanelUMG_IsPlayingAnimation final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPanelUMG_IsPlayingAnimation) == 0x000001, "Wrong alignment on WSPanelUMG_IsPlayingAnimation");
static_assert(sizeof(WSPanelUMG_IsPlayingAnimation) == 0x000001, "Wrong size on WSPanelUMG_IsPlayingAnimation");
static_assert(offsetof(WSPanelUMG_IsPlayingAnimation, ReturnValue) == 0x000000, "Member 'WSPanelUMG_IsPlayingAnimation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDoor.CloseDoor
// 0x0010 (0x0010 - 0x0000)
struct PhxDoor_CloseDoor final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bQueueIfBusy;                                      // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDoor_CloseDoor) == 0x000008, "Wrong alignment on PhxDoor_CloseDoor");
static_assert(sizeof(PhxDoor_CloseDoor) == 0x000010, "Wrong size on PhxDoor_CloseDoor");
static_assert(offsetof(PhxDoor_CloseDoor, InteractedBy) == 0x000000, "Member 'PhxDoor_CloseDoor::InteractedBy' has a wrong offset!");
static_assert(offsetof(PhxDoor_CloseDoor, bQueueIfBusy) == 0x000008, "Member 'PhxDoor_CloseDoor::bQueueIfBusy' has a wrong offset!");

// Function Phoenix.PhxDoor.DisableScriptedMode
// 0x0002 (0x0002 - 0x0000)
struct PhxDoor_DisableScriptedMode final
{
public:
	EPhxDoorScriptedModeTransitionOut             ScriptedModeTransition;                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsDoorOpen;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_DisableScriptedMode) == 0x000001, "Wrong alignment on PhxDoor_DisableScriptedMode");
static_assert(sizeof(PhxDoor_DisableScriptedMode) == 0x000002, "Wrong size on PhxDoor_DisableScriptedMode");
static_assert(offsetof(PhxDoor_DisableScriptedMode, ScriptedModeTransition) == 0x000000, "Member 'PhxDoor_DisableScriptedMode::ScriptedModeTransition' has a wrong offset!");
static_assert(offsetof(PhxDoor_DisableScriptedMode, bIsDoorOpen) == 0x000001, "Member 'PhxDoor_DisableScriptedMode::bIsDoorOpen' has a wrong offset!");

// Function Phoenix.PhxDoor.EndKeycodeScan
// 0x0001 (0x0001 - 0x0000)
struct PhxDoor_EndKeycodeScan final
{
public:
	bool                                          bSuccessful;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_EndKeycodeScan) == 0x000001, "Wrong alignment on PhxDoor_EndKeycodeScan");
static_assert(sizeof(PhxDoor_EndKeycodeScan) == 0x000001, "Wrong size on PhxDoor_EndKeycodeScan");
static_assert(offsetof(PhxDoor_EndKeycodeScan, bSuccessful) == 0x000000, "Member 'PhxDoor_EndKeycodeScan::bSuccessful' has a wrong offset!");

// Function Phoenix.PhxDoor.LockDoor
// 0x0002 (0x0002 - 0x0000)
struct PhxDoor_LockDoor final
{
public:
	bool                                          bLockSideA;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLockSideB;                                        // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_LockDoor) == 0x000001, "Wrong alignment on PhxDoor_LockDoor");
static_assert(sizeof(PhxDoor_LockDoor) == 0x000002, "Wrong size on PhxDoor_LockDoor");
static_assert(offsetof(PhxDoor_LockDoor, bLockSideA) == 0x000000, "Member 'PhxDoor_LockDoor::bLockSideA' has a wrong offset!");
static_assert(offsetof(PhxDoor_LockDoor, bLockSideB) == 0x000001, "Member 'PhxDoor_LockDoor::bLockSideB' has a wrong offset!");

// Function Phoenix.PhxDoor.OnInteractableProximityChanged
// 0x0002 (0x0002 - 0x0000)
struct PhxDoor_OnInteractableProximityChanged final
{
public:
	EInteractableProximity                        Proximity;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInteractableProximity                        PreviousProximity;                                 // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_OnInteractableProximityChanged) == 0x000001, "Wrong alignment on PhxDoor_OnInteractableProximityChanged");
static_assert(sizeof(PhxDoor_OnInteractableProximityChanged) == 0x000002, "Wrong size on PhxDoor_OnInteractableProximityChanged");
static_assert(offsetof(PhxDoor_OnInteractableProximityChanged, Proximity) == 0x000000, "Member 'PhxDoor_OnInteractableProximityChanged::Proximity' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnInteractableProximityChanged, PreviousProximity) == 0x000001, "Member 'PhxDoor_OnInteractableProximityChanged::PreviousProximity' has a wrong offset!");

// Function Phoenix.PhxDoor.OnProximityBoxBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxDoor_OnProximityBoxBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_OnProximityBoxBeginOverlap) == 0x000008, "Wrong alignment on PhxDoor_OnProximityBoxBeginOverlap");
static_assert(sizeof(PhxDoor_OnProximityBoxBeginOverlap) == 0x0000A8, "Wrong size on PhxDoor_OnProximityBoxBeginOverlap");
static_assert(offsetof(PhxDoor_OnProximityBoxBeginOverlap, OverlappedComponent) == 0x000000, "Member 'PhxDoor_OnProximityBoxBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnProximityBoxBeginOverlap, OtherActor) == 0x000008, "Member 'PhxDoor_OnProximityBoxBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnProximityBoxBeginOverlap, OtherComp) == 0x000010, "Member 'PhxDoor_OnProximityBoxBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnProximityBoxBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxDoor_OnProximityBoxBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnProximityBoxBeginOverlap, bFromSweep) == 0x00001C, "Member 'PhxDoor_OnProximityBoxBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnProximityBoxBeginOverlap, SweepResult) == 0x000020, "Member 'PhxDoor_OnProximityBoxBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxDoor.OnProximityBoxEndOverlap
// 0x0020 (0x0020 - 0x0000)
struct PhxDoor_OnProximityBoxEndOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDoor_OnProximityBoxEndOverlap) == 0x000008, "Wrong alignment on PhxDoor_OnProximityBoxEndOverlap");
static_assert(sizeof(PhxDoor_OnProximityBoxEndOverlap) == 0x000020, "Wrong size on PhxDoor_OnProximityBoxEndOverlap");
static_assert(offsetof(PhxDoor_OnProximityBoxEndOverlap, OverlappedComponent) == 0x000000, "Member 'PhxDoor_OnProximityBoxEndOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnProximityBoxEndOverlap, OtherActor) == 0x000008, "Member 'PhxDoor_OnProximityBoxEndOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnProximityBoxEndOverlap, OtherComp) == 0x000010, "Member 'PhxDoor_OnProximityBoxEndOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnProximityBoxEndOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxDoor_OnProximityBoxEndOverlap::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PhxDoor.OnPushVolumeBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxDoor_OnPushVolumeBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_OnPushVolumeBeginOverlap) == 0x000008, "Wrong alignment on PhxDoor_OnPushVolumeBeginOverlap");
static_assert(sizeof(PhxDoor_OnPushVolumeBeginOverlap) == 0x0000A8, "Wrong size on PhxDoor_OnPushVolumeBeginOverlap");
static_assert(offsetof(PhxDoor_OnPushVolumeBeginOverlap, OverlappedComponent) == 0x000000, "Member 'PhxDoor_OnPushVolumeBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnPushVolumeBeginOverlap, OtherActor) == 0x000008, "Member 'PhxDoor_OnPushVolumeBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnPushVolumeBeginOverlap, OtherComp) == 0x000010, "Member 'PhxDoor_OnPushVolumeBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnPushVolumeBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxDoor_OnPushVolumeBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnPushVolumeBeginOverlap, bFromSweep) == 0x00001C, "Member 'PhxDoor_OnPushVolumeBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnPushVolumeBeginOverlap, SweepResult) == 0x000020, "Member 'PhxDoor_OnPushVolumeBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxDoor.OnPushVolumeEndOverlap
// 0x0020 (0x0020 - 0x0000)
struct PhxDoor_OnPushVolumeEndOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDoor_OnPushVolumeEndOverlap) == 0x000008, "Wrong alignment on PhxDoor_OnPushVolumeEndOverlap");
static_assert(sizeof(PhxDoor_OnPushVolumeEndOverlap) == 0x000020, "Wrong size on PhxDoor_OnPushVolumeEndOverlap");
static_assert(offsetof(PhxDoor_OnPushVolumeEndOverlap, OverlappedComponent) == 0x000000, "Member 'PhxDoor_OnPushVolumeEndOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnPushVolumeEndOverlap, OtherActor) == 0x000008, "Member 'PhxDoor_OnPushVolumeEndOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnPushVolumeEndOverlap, OtherComp) == 0x000010, "Member 'PhxDoor_OnPushVolumeEndOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxDoor_OnPushVolumeEndOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxDoor_OnPushVolumeEndOverlap::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PhxDoor.OnSideAInteraction
// 0x0008 (0x0008 - 0x0000)
struct PhxDoor_OnSideAInteraction final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_OnSideAInteraction) == 0x000008, "Wrong alignment on PhxDoor_OnSideAInteraction");
static_assert(sizeof(PhxDoor_OnSideAInteraction) == 0x000008, "Wrong size on PhxDoor_OnSideAInteraction");
static_assert(offsetof(PhxDoor_OnSideAInteraction, InteractedBy) == 0x000000, "Member 'PhxDoor_OnSideAInteraction::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxDoor.OnSideBInteraction
// 0x0008 (0x0008 - 0x0000)
struct PhxDoor_OnSideBInteraction final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_OnSideBInteraction) == 0x000008, "Wrong alignment on PhxDoor_OnSideBInteraction");
static_assert(sizeof(PhxDoor_OnSideBInteraction) == 0x000008, "Wrong size on PhxDoor_OnSideBInteraction");
static_assert(offsetof(PhxDoor_OnSideBInteraction, InteractedBy) == 0x000000, "Member 'PhxDoor_OnSideBInteraction::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxDoor.OpenDoor
// 0x0010 (0x0010 - 0x0000)
struct PhxDoor_OpenDoor final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bQueueIfBusy;                                      // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDoor_OpenDoor) == 0x000008, "Wrong alignment on PhxDoor_OpenDoor");
static_assert(sizeof(PhxDoor_OpenDoor) == 0x000010, "Wrong size on PhxDoor_OpenDoor");
static_assert(offsetof(PhxDoor_OpenDoor, InteractedBy) == 0x000000, "Member 'PhxDoor_OpenDoor::InteractedBy' has a wrong offset!");
static_assert(offsetof(PhxDoor_OpenDoor, bQueueIfBusy) == 0x000008, "Member 'PhxDoor_OpenDoor::bQueueIfBusy' has a wrong offset!");

// Function Phoenix.PhxDoor.SetDoorRemainsOpen
// 0x0001 (0x0001 - 0x0000)
struct PhxDoor_SetDoorRemainsOpen final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_SetDoorRemainsOpen) == 0x000001, "Wrong alignment on PhxDoor_SetDoorRemainsOpen");
static_assert(sizeof(PhxDoor_SetDoorRemainsOpen) == 0x000001, "Wrong size on PhxDoor_SetDoorRemainsOpen");
static_assert(offsetof(PhxDoor_SetDoorRemainsOpen, bEnabled) == 0x000000, "Member 'PhxDoor_SetDoorRemainsOpen::bEnabled' has a wrong offset!");

// Function Phoenix.PhxDoor.SetProximityClose
// 0x0001 (0x0001 - 0x0000)
struct PhxDoor_SetProximityClose final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_SetProximityClose) == 0x000001, "Wrong alignment on PhxDoor_SetProximityClose");
static_assert(sizeof(PhxDoor_SetProximityClose) == 0x000001, "Wrong size on PhxDoor_SetProximityClose");
static_assert(offsetof(PhxDoor_SetProximityClose, bEnabled) == 0x000000, "Member 'PhxDoor_SetProximityClose::bEnabled' has a wrong offset!");

// Function Phoenix.PhxDoor.SetProximityOpen
// 0x0001 (0x0001 - 0x0000)
struct PhxDoor_SetProximityOpen final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_SetProximityOpen) == 0x000001, "Wrong alignment on PhxDoor_SetProximityOpen");
static_assert(sizeof(PhxDoor_SetProximityOpen) == 0x000001, "Wrong size on PhxDoor_SetProximityOpen");
static_assert(offsetof(PhxDoor_SetProximityOpen, bEnabled) == 0x000000, "Member 'PhxDoor_SetProximityOpen::bEnabled' has a wrong offset!");

// Function Phoenix.PhxDoor.SetUnlockDoorAfterOpening
// 0x0001 (0x0001 - 0x0000)
struct PhxDoor_SetUnlockDoorAfterOpening final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_SetUnlockDoorAfterOpening) == 0x000001, "Wrong alignment on PhxDoor_SetUnlockDoorAfterOpening");
static_assert(sizeof(PhxDoor_SetUnlockDoorAfterOpening) == 0x000001, "Wrong size on PhxDoor_SetUnlockDoorAfterOpening");
static_assert(offsetof(PhxDoor_SetUnlockDoorAfterOpening, bEnabled) == 0x000000, "Member 'PhxDoor_SetUnlockDoorAfterOpening::bEnabled' has a wrong offset!");

// Function Phoenix.PhxDoor.UnlockDoor
// 0x0002 (0x0002 - 0x0000)
struct PhxDoor_UnlockDoor final
{
public:
	bool                                          bUnlockSideA;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUnlockSideB;                                      // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_UnlockDoor) == 0x000001, "Wrong alignment on PhxDoor_UnlockDoor");
static_assert(sizeof(PhxDoor_UnlockDoor) == 0x000002, "Wrong size on PhxDoor_UnlockDoor");
static_assert(offsetof(PhxDoor_UnlockDoor, bUnlockSideA) == 0x000000, "Member 'PhxDoor_UnlockDoor::bUnlockSideA' has a wrong offset!");
static_assert(offsetof(PhxDoor_UnlockDoor, bUnlockSideB) == 0x000001, "Member 'PhxDoor_UnlockDoor::bUnlockSideB' has a wrong offset!");

// Function Phoenix.PhxDoor.CanDoorQueueOpenCommand
// 0x0001 (0x0001 - 0x0000)
struct PhxDoor_CanDoorQueueOpenCommand final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDoor_CanDoorQueueOpenCommand) == 0x000001, "Wrong alignment on PhxDoor_CanDoorQueueOpenCommand");
static_assert(sizeof(PhxDoor_CanDoorQueueOpenCommand) == 0x000001, "Wrong size on PhxDoor_CanDoorQueueOpenCommand");
static_assert(offsetof(PhxDoor_CanDoorQueueOpenCommand, ReturnValue) == 0x000000, "Member 'PhxDoor_CanDoorQueueOpenCommand::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDoor.GetDoorUIStates
// 0x0010 (0x0010 - 0x0000)
struct PhxDoor_GetDoorUIStates final
{
public:
	const class APhxCharacter*                    Character;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxDoorUIState                               SideAState;                                        // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxDoorUIState                               SideBState;                                        // 0x0009(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDoor_GetDoorUIStates) == 0x000008, "Wrong alignment on PhxDoor_GetDoorUIStates");
static_assert(sizeof(PhxDoor_GetDoorUIStates) == 0x000010, "Wrong size on PhxDoor_GetDoorUIStates");
static_assert(offsetof(PhxDoor_GetDoorUIStates, Character) == 0x000000, "Member 'PhxDoor_GetDoorUIStates::Character' has a wrong offset!");
static_assert(offsetof(PhxDoor_GetDoorUIStates, SideAState) == 0x000008, "Member 'PhxDoor_GetDoorUIStates::SideAState' has a wrong offset!");
static_assert(offsetof(PhxDoor_GetDoorUIStates, SideBState) == 0x000009, "Member 'PhxDoor_GetDoorUIStates::SideBState' has a wrong offset!");

// Function Phoenix.PhxDoor.IsCharacterOnSideA
// 0x0010 (0x0010 - 0x0000)
struct PhxDoor_IsCharacterOnSideA final
{
public:
	const class APhxCharacter*                    Character;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDoor_IsCharacterOnSideA) == 0x000008, "Wrong alignment on PhxDoor_IsCharacterOnSideA");
static_assert(sizeof(PhxDoor_IsCharacterOnSideA) == 0x000010, "Wrong size on PhxDoor_IsCharacterOnSideA");
static_assert(offsetof(PhxDoor_IsCharacterOnSideA, Character) == 0x000000, "Member 'PhxDoor_IsCharacterOnSideA::Character' has a wrong offset!");
static_assert(offsetof(PhxDoor_IsCharacterOnSideA, ReturnValue) == 0x000008, "Member 'PhxDoor_IsCharacterOnSideA::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDoor.IsCharacterOnSideB
// 0x0010 (0x0010 - 0x0000)
struct PhxDoor_IsCharacterOnSideB final
{
public:
	const class APhxCharacter*                    Character;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDoor_IsCharacterOnSideB) == 0x000008, "Wrong alignment on PhxDoor_IsCharacterOnSideB");
static_assert(sizeof(PhxDoor_IsCharacterOnSideB) == 0x000010, "Wrong size on PhxDoor_IsCharacterOnSideB");
static_assert(offsetof(PhxDoor_IsCharacterOnSideB, Character) == 0x000000, "Member 'PhxDoor_IsCharacterOnSideB::Character' has a wrong offset!");
static_assert(offsetof(PhxDoor_IsCharacterOnSideB, ReturnValue) == 0x000008, "Member 'PhxDoor_IsCharacterOnSideB::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxVehiclePawn.ResetVehicle
// 0x0018 (0x0018 - 0x0000)
struct PhxVehiclePawn_ResetVehicle final
{
public:
	struct FVector                                WCM_Position;                                      // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               Rotation;                                          // 0x000C(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehiclePawn_ResetVehicle) == 0x000004, "Wrong alignment on PhxVehiclePawn_ResetVehicle");
static_assert(sizeof(PhxVehiclePawn_ResetVehicle) == 0x000018, "Wrong size on PhxVehiclePawn_ResetVehicle");
static_assert(offsetof(PhxVehiclePawn_ResetVehicle, WCM_Position) == 0x000000, "Member 'PhxVehiclePawn_ResetVehicle::WCM_Position' has a wrong offset!");
static_assert(offsetof(PhxVehiclePawn_ResetVehicle, Rotation) == 0x00000C, "Member 'PhxVehiclePawn_ResetVehicle::Rotation' has a wrong offset!");

// Function Phoenix.PhxVehiclePawn.GetShouldVehicleResetToCheckpoint
// 0x0001 (0x0001 - 0x0000)
struct PhxVehiclePawn_GetShouldVehicleResetToCheckpoint final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehiclePawn_GetShouldVehicleResetToCheckpoint) == 0x000001, "Wrong alignment on PhxVehiclePawn_GetShouldVehicleResetToCheckpoint");
static_assert(sizeof(PhxVehiclePawn_GetShouldVehicleResetToCheckpoint) == 0x000001, "Wrong size on PhxVehiclePawn_GetShouldVehicleResetToCheckpoint");
static_assert(offsetof(PhxVehiclePawn_GetShouldVehicleResetToCheckpoint, ReturnValue) == 0x000000, "Member 'PhxVehiclePawn_GetShouldVehicleResetToCheckpoint::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWeakSpotComponent.SetEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxWeakSpotComponent_SetEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeakSpotComponent_SetEnabled) == 0x000001, "Wrong alignment on PhxWeakSpotComponent_SetEnabled");
static_assert(sizeof(PhxWeakSpotComponent_SetEnabled) == 0x000001, "Wrong size on PhxWeakSpotComponent_SetEnabled");
static_assert(offsetof(PhxWeakSpotComponent_SetEnabled, bEnable) == 0x000000, "Member 'PhxWeakSpotComponent_SetEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxWeakSpotComponent.IsEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxWeakSpotComponent_IsEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeakSpotComponent_IsEnabled) == 0x000001, "Wrong alignment on PhxWeakSpotComponent_IsEnabled");
static_assert(sizeof(PhxWeakSpotComponent_IsEnabled) == 0x000001, "Wrong size on PhxWeakSpotComponent_IsEnabled");
static_assert(offsetof(PhxWeakSpotComponent_IsEnabled, ReturnValue) == 0x000000, "Member 'PhxWeakSpotComponent_IsEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCorpse.GetMeshBoneData
// 0x00D8 (0x00D8 - 0x0000)
struct PhxCorpse_GetMeshBoneData final
{
public:
	class FName                                   BoneName;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMeshBoneData                          BoneData;                                          // 0x0008(0x00C8)(Parm, OutParm, ContainsInstancedReference, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00D0(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D1[0x7];                                       // 0x00D1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCorpse_GetMeshBoneData) == 0x000008, "Wrong alignment on PhxCorpse_GetMeshBoneData");
static_assert(sizeof(PhxCorpse_GetMeshBoneData) == 0x0000D8, "Wrong size on PhxCorpse_GetMeshBoneData");
static_assert(offsetof(PhxCorpse_GetMeshBoneData, BoneName) == 0x000000, "Member 'PhxCorpse_GetMeshBoneData::BoneName' has a wrong offset!");
static_assert(offsetof(PhxCorpse_GetMeshBoneData, BoneData) == 0x000008, "Member 'PhxCorpse_GetMeshBoneData::BoneData' has a wrong offset!");
static_assert(offsetof(PhxCorpse_GetMeshBoneData, ReturnValue) == 0x0000D0, "Member 'PhxCorpse_GetMeshBoneData::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHarvestCorpse.OnInteract
// 0x0008 (0x0008 - 0x0000)
struct PhxHarvestCorpse_OnInteract final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHarvestCorpse_OnInteract) == 0x000008, "Wrong alignment on PhxHarvestCorpse_OnInteract");
static_assert(sizeof(PhxHarvestCorpse_OnInteract) == 0x000008, "Wrong size on PhxHarvestCorpse_OnInteract");
static_assert(offsetof(PhxHarvestCorpse_OnInteract, InteractedBy) == 0x000000, "Member 'PhxHarvestCorpse_OnInteract::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxPPEHitResponseComponent.OnPPEHitBPE
// 0x0038 (0x0038 - 0x0000)
struct PhxPPEHitResponseComponent_OnPPEHitBPE final
{
public:
	struct FPPEHitResponseData                    ResponseData;                                      // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPPEHitResponseComponent_OnPPEHitBPE) == 0x000008, "Wrong alignment on PhxPPEHitResponseComponent_OnPPEHitBPE");
static_assert(sizeof(PhxPPEHitResponseComponent_OnPPEHitBPE) == 0x000038, "Wrong size on PhxPPEHitResponseComponent_OnPPEHitBPE");
static_assert(offsetof(PhxPPEHitResponseComponent_OnPPEHitBPE, ResponseData) == 0x000000, "Member 'PhxPPEHitResponseComponent_OnPPEHitBPE::ResponseData' has a wrong offset!");

// Function Phoenix.PhxWaitForLevelStreamingComplete.CreateWaitForLevelStreamingComplete
// 0x0028 (0x0028 - 0x0000)
struct PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<TSoftObjectPtr<class UWorld>>          InLevelsToCheck;                                   // 0x0008(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          CheckIfLoaded_0;                                   // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x3];                                       // 0x0019(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TimerInterval_0;                                   // 0x001C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxWaitForLevelStreamingComplete*      ReturnValue;                                       // 0x0020(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete) == 0x000008, "Wrong alignment on PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete");
static_assert(sizeof(PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete) == 0x000028, "Wrong size on PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete");
static_assert(offsetof(PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete, WorldContextObject) == 0x000000, "Member 'PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete, InLevelsToCheck) == 0x000008, "Member 'PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete::InLevelsToCheck' has a wrong offset!");
static_assert(offsetof(PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete, CheckIfLoaded_0) == 0x000018, "Member 'PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete::CheckIfLoaded_0' has a wrong offset!");
static_assert(offsetof(PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete, TimerInterval_0) == 0x00001C, "Member 'PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete::TimerInterval_0' has a wrong offset!");
static_assert(offsetof(PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete, ReturnValue) == 0x000020, "Member 'PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnMoveAlongSplineCompleted
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayAbility_Traverse_Spline_OnMoveAlongSplineCompleted final
{
public:
	ESplineEnd                                    InSplineExitEnd;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_Traverse_Spline_OnMoveAlongSplineCompleted) == 0x000001, "Wrong alignment on PhxGameplayAbility_Traverse_Spline_OnMoveAlongSplineCompleted");
static_assert(sizeof(PhxGameplayAbility_Traverse_Spline_OnMoveAlongSplineCompleted) == 0x000001, "Wrong size on PhxGameplayAbility_Traverse_Spline_OnMoveAlongSplineCompleted");
static_assert(offsetof(PhxGameplayAbility_Traverse_Spline_OnMoveAlongSplineCompleted, InSplineExitEnd) == 0x000000, "Member 'PhxGameplayAbility_Traverse_Spline_OnMoveAlongSplineCompleted::InSplineExitEnd' has a wrong offset!");

// Function Phoenix.SDSAudioLogButton.SetOrderNumber
// 0x0018 (0x0018 - 0x0000)
struct SDSAudioLogButton_SetOrderNumber final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSAudioLogButton_SetOrderNumber) == 0x000008, "Wrong alignment on SDSAudioLogButton_SetOrderNumber");
static_assert(sizeof(SDSAudioLogButton_SetOrderNumber) == 0x000018, "Wrong size on SDSAudioLogButton_SetOrderNumber");
static_assert(offsetof(SDSAudioLogButton_SetOrderNumber, InText) == 0x000000, "Member 'SDSAudioLogButton_SetOrderNumber::InText' has a wrong offset!");

// Function Phoenix.SDSAudioLogButton.SetPlaying
// 0x0001 (0x0001 - 0x0000)
struct SDSAudioLogButton_SetPlaying final
{
public:
	bool                                          bPlaying;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSAudioLogButton_SetPlaying) == 0x000001, "Wrong alignment on SDSAudioLogButton_SetPlaying");
static_assert(sizeof(SDSAudioLogButton_SetPlaying) == 0x000001, "Wrong size on SDSAudioLogButton_SetPlaying");
static_assert(offsetof(SDSAudioLogButton_SetPlaying, bPlaying) == 0x000000, "Member 'SDSAudioLogButton_SetPlaying::bPlaying' has a wrong offset!");

// Function Phoenix.SDSAudioLogButton.SetTitle
// 0x0018 (0x0018 - 0x0000)
struct SDSAudioLogButton_SetTitle final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSAudioLogButton_SetTitle) == 0x000008, "Wrong alignment on SDSAudioLogButton_SetTitle");
static_assert(sizeof(SDSAudioLogButton_SetTitle) == 0x000018, "Wrong size on SDSAudioLogButton_SetTitle");
static_assert(offsetof(SDSAudioLogButton_SetTitle, InText) == 0x000000, "Member 'SDSAudioLogButton_SetTitle::InText' has a wrong offset!");

// Function Phoenix.SDSAudioLogButton.IsPlaying
// 0x0001 (0x0001 - 0x0000)
struct SDSAudioLogButton_IsPlaying final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSAudioLogButton_IsPlaying) == 0x000001, "Wrong alignment on SDSAudioLogButton_IsPlaying");
static_assert(sizeof(SDSAudioLogButton_IsPlaying) == 0x000001, "Wrong size on SDSAudioLogButton_IsPlaying");
static_assert(offsetof(SDSAudioLogButton_IsPlaying, ReturnValue) == 0x000000, "Member 'SDSAudioLogButton_IsPlaying::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSKitBash.HandleInteraction
// 0x0008 (0x0008 - 0x0000)
struct SDSKitBash_HandleInteraction final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSKitBash_HandleInteraction) == 0x000008, "Wrong alignment on SDSKitBash_HandleInteraction");
static_assert(sizeof(SDSKitBash_HandleInteraction) == 0x000008, "Wrong size on SDSKitBash_HandleInteraction");
static_assert(offsetof(SDSKitBash_HandleInteraction, InteractedBy) == 0x000000, "Member 'SDSKitBash_HandleInteraction::InteractedBy' has a wrong offset!");

// Function Phoenix.SDSKitBash.GetChildActor
// 0x0008 (0x0008 - 0x0000)
struct SDSKitBash_GetChildActor final
{
public:
	class AActor*                                 ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSKitBash_GetChildActor) == 0x000008, "Wrong alignment on SDSKitBash_GetChildActor");
static_assert(sizeof(SDSKitBash_GetChildActor) == 0x000008, "Wrong size on SDSKitBash_GetChildActor");
static_assert(offsetof(SDSKitBash_GetChildActor, ReturnValue) == 0x000000, "Member 'SDSKitBash_GetChildActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterWidget.AddDynamicSpace
// 0x0008 (0x0008 - 0x0000)
struct PhxLevelPacingMeterWidget_AddDynamicSpace final
{
public:
	class APhxLevelPacingMeterSpace*              NewLevelSpace;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterWidget_AddDynamicSpace) == 0x000008, "Wrong alignment on PhxLevelPacingMeterWidget_AddDynamicSpace");
static_assert(sizeof(PhxLevelPacingMeterWidget_AddDynamicSpace) == 0x000008, "Wrong size on PhxLevelPacingMeterWidget_AddDynamicSpace");
static_assert(offsetof(PhxLevelPacingMeterWidget_AddDynamicSpace, NewLevelSpace) == 0x000000, "Member 'PhxLevelPacingMeterWidget_AddDynamicSpace::NewLevelSpace' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterWidget.SetupStaticMeter
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelPacingMeterWidget_SetupStaticMeter final
{
public:
	TArray<class APhxLevelPacingMeterSpace*>      NewLevelPacingSpaces;                              // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterWidget_SetupStaticMeter) == 0x000008, "Wrong alignment on PhxLevelPacingMeterWidget_SetupStaticMeter");
static_assert(sizeof(PhxLevelPacingMeterWidget_SetupStaticMeter) == 0x000010, "Wrong size on PhxLevelPacingMeterWidget_SetupStaticMeter");
static_assert(offsetof(PhxLevelPacingMeterWidget_SetupStaticMeter, NewLevelPacingSpaces) == 0x000000, "Member 'PhxLevelPacingMeterWidget_SetupStaticMeter::NewLevelPacingSpaces' has a wrong offset!");

// Function Phoenix.PhxBTTask_PlayPostSpawnAnimation.OnMontageBlendingOut
// 0x0010 (0x0010 - 0x0000)
struct PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut final
{
public:
	class UAnimMontage*                           Montage;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInterrupted;                                      // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut) == 0x000008, "Wrong alignment on PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut");
static_assert(sizeof(PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut) == 0x000010, "Wrong size on PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut");
static_assert(offsetof(PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut, Montage) == 0x000000, "Member 'PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut::Montage' has a wrong offset!");
static_assert(offsetof(PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut, bInterrupted) == 0x000008, "Member 'PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut::bInterrupted' has a wrong offset!");

// Function Phoenix.PhxTreadmill.ActivateTreadmill
// 0x0010 (0x0010 - 0x0000)
struct PhxTreadmill_ActivateTreadmill final
{
public:
	bool                                          bActive;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class AActor*                                 ForUser;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTreadmill_ActivateTreadmill) == 0x000008, "Wrong alignment on PhxTreadmill_ActivateTreadmill");
static_assert(sizeof(PhxTreadmill_ActivateTreadmill) == 0x000010, "Wrong size on PhxTreadmill_ActivateTreadmill");
static_assert(offsetof(PhxTreadmill_ActivateTreadmill, bActive) == 0x000000, "Member 'PhxTreadmill_ActivateTreadmill::bActive' has a wrong offset!");
static_assert(offsetof(PhxTreadmill_ActivateTreadmill, ForUser) == 0x000008, "Member 'PhxTreadmill_ActivateTreadmill::ForUser' has a wrong offset!");

// Function Phoenix.PhxTreadmill.OnPostSpawnTile
// 0x0008 (0x0008 - 0x0000)
struct PhxTreadmill_OnPostSpawnTile final
{
public:
	class AActor*                                 TileActor;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTreadmill_OnPostSpawnTile) == 0x000008, "Wrong alignment on PhxTreadmill_OnPostSpawnTile");
static_assert(sizeof(PhxTreadmill_OnPostSpawnTile) == 0x000008, "Wrong size on PhxTreadmill_OnPostSpawnTile");
static_assert(offsetof(PhxTreadmill_OnPostSpawnTile, TileActor) == 0x000000, "Member 'PhxTreadmill_OnPostSpawnTile::TileActor' has a wrong offset!");

// Function Phoenix.PhxTreadmill.OnPreUnspawnTile
// 0x0008 (0x0008 - 0x0000)
struct PhxTreadmill_OnPreUnspawnTile final
{
public:
	class AActor*                                 TileActor;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTreadmill_OnPreUnspawnTile) == 0x000008, "Wrong alignment on PhxTreadmill_OnPreUnspawnTile");
static_assert(sizeof(PhxTreadmill_OnPreUnspawnTile) == 0x000008, "Wrong size on PhxTreadmill_OnPreUnspawnTile");
static_assert(offsetof(PhxTreadmill_OnPreUnspawnTile, TileActor) == 0x000000, "Member 'PhxTreadmill_OnPreUnspawnTile::TileActor' has a wrong offset!");

// Function Phoenix.PhxTreadmill.OnTreadmillMoved
// 0x000C (0x000C - 0x0000)
struct PhxTreadmill_OnTreadmillMoved final
{
public:
	struct FVector                                Translation;                                       // 0x0000(0x000C)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTreadmill_OnTreadmillMoved) == 0x000004, "Wrong alignment on PhxTreadmill_OnTreadmillMoved");
static_assert(sizeof(PhxTreadmill_OnTreadmillMoved) == 0x00000C, "Wrong size on PhxTreadmill_OnTreadmillMoved");
static_assert(offsetof(PhxTreadmill_OnTreadmillMoved, Translation) == 0x000000, "Member 'PhxTreadmill_OnTreadmillMoved::Translation' has a wrong offset!");

// Function Phoenix.PhxTutorialSystem.RequestTutorialHint
// 0x0050 (0x0050 - 0x0000)
struct PhxTutorialSystem_RequestTutorialHint final
{
public:
	struct FTutorialHintRequest                   InRequest;                                         // 0x0000(0x0040)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnSuccess;                                         // 0x0040(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTutorialSystem_RequestTutorialHint) == 0x000008, "Wrong alignment on PhxTutorialSystem_RequestTutorialHint");
static_assert(sizeof(PhxTutorialSystem_RequestTutorialHint) == 0x000050, "Wrong size on PhxTutorialSystem_RequestTutorialHint");
static_assert(offsetof(PhxTutorialSystem_RequestTutorialHint, InRequest) == 0x000000, "Member 'PhxTutorialSystem_RequestTutorialHint::InRequest' has a wrong offset!");
static_assert(offsetof(PhxTutorialSystem_RequestTutorialHint, OnSuccess) == 0x000040, "Member 'PhxTutorialSystem_RequestTutorialHint::OnSuccess' has a wrong offset!");

// Function Phoenix.PhxDialogueSystem.OnCharacterRagdoll
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueSystem_OnCharacterRagdoll final
{
public:
	class UPhxSkeletalMeshComponent*              MeshComp;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueSystem_OnCharacterRagdoll) == 0x000008, "Wrong alignment on PhxDialogueSystem_OnCharacterRagdoll");
static_assert(sizeof(PhxDialogueSystem_OnCharacterRagdoll) == 0x000008, "Wrong size on PhxDialogueSystem_OnCharacterRagdoll");
static_assert(offsetof(PhxDialogueSystem_OnCharacterRagdoll, MeshComp) == 0x000000, "Member 'PhxDialogueSystem_OnCharacterRagdoll::MeshComp' has a wrong offset!");

// Function Phoenix.PhxDialogueSystem.PauseAudioLog
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueSystem_PauseAudioLog final
{
public:
	class UDialogue*                              InAudioLog;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueSystem_PauseAudioLog) == 0x000008, "Wrong alignment on PhxDialogueSystem_PauseAudioLog");
static_assert(sizeof(PhxDialogueSystem_PauseAudioLog) == 0x000008, "Wrong size on PhxDialogueSystem_PauseAudioLog");
static_assert(offsetof(PhxDialogueSystem_PauseAudioLog, InAudioLog) == 0x000000, "Member 'PhxDialogueSystem_PauseAudioLog::InAudioLog' has a wrong offset!");

// Function Phoenix.PhxDialogueSystem.PlayAudioLog
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueSystem_PlayAudioLog final
{
public:
	class UDialogue*                              InAudioLog;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Speaker;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueSystem_PlayAudioLog) == 0x000008, "Wrong alignment on PhxDialogueSystem_PlayAudioLog");
static_assert(sizeof(PhxDialogueSystem_PlayAudioLog) == 0x000010, "Wrong size on PhxDialogueSystem_PlayAudioLog");
static_assert(offsetof(PhxDialogueSystem_PlayAudioLog, InAudioLog) == 0x000000, "Member 'PhxDialogueSystem_PlayAudioLog::InAudioLog' has a wrong offset!");
static_assert(offsetof(PhxDialogueSystem_PlayAudioLog, Speaker) == 0x000008, "Member 'PhxDialogueSystem_PlayAudioLog::Speaker' has a wrong offset!");

// Function Phoenix.PhxDialogueSystem.PlayDialogue
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueSystem_PlayDialogue final
{
public:
	class UDialogue*                              InDialogue;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 SpeakingActor;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueSystem_PlayDialogue) == 0x000008, "Wrong alignment on PhxDialogueSystem_PlayDialogue");
static_assert(sizeof(PhxDialogueSystem_PlayDialogue) == 0x000010, "Wrong size on PhxDialogueSystem_PlayDialogue");
static_assert(offsetof(PhxDialogueSystem_PlayDialogue, InDialogue) == 0x000000, "Member 'PhxDialogueSystem_PlayDialogue::InDialogue' has a wrong offset!");
static_assert(offsetof(PhxDialogueSystem_PlayDialogue, SpeakingActor) == 0x000008, "Member 'PhxDialogueSystem_PlayDialogue::SpeakingActor' has a wrong offset!");

// Function Phoenix.PhxDialogueSystem.SetDialogueDebug
// 0x0001 (0x0001 - 0x0000)
struct PhxDialogueSystem_SetDialogueDebug final
{
public:
	bool                                          Enabled;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueSystem_SetDialogueDebug) == 0x000001, "Wrong alignment on PhxDialogueSystem_SetDialogueDebug");
static_assert(sizeof(PhxDialogueSystem_SetDialogueDebug) == 0x000001, "Wrong size on PhxDialogueSystem_SetDialogueDebug");
static_assert(offsetof(PhxDialogueSystem_SetDialogueDebug, Enabled) == 0x000000, "Member 'PhxDialogueSystem_SetDialogueDebug::Enabled' has a wrong offset!");

// Function Phoenix.PhxDialogueSystem.StopAllDialogueOnActor
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueSystem_StopAllDialogueOnActor final
{
public:
	class AActor*                                 Actor;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueSystem_StopAllDialogueOnActor) == 0x000008, "Wrong alignment on PhxDialogueSystem_StopAllDialogueOnActor");
static_assert(sizeof(PhxDialogueSystem_StopAllDialogueOnActor) == 0x000008, "Wrong size on PhxDialogueSystem_StopAllDialogueOnActor");
static_assert(offsetof(PhxDialogueSystem_StopAllDialogueOnActor, Actor) == 0x000000, "Member 'PhxDialogueSystem_StopAllDialogueOnActor::Actor' has a wrong offset!");

// Function Phoenix.PhxDialogueSystem.StopAudioLog
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueSystem_StopAudioLog final
{
public:
	class UDialogue*                              InAudioLog;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueSystem_StopAudioLog) == 0x000008, "Wrong alignment on PhxDialogueSystem_StopAudioLog");
static_assert(sizeof(PhxDialogueSystem_StopAudioLog) == 0x000008, "Wrong size on PhxDialogueSystem_StopAudioLog");
static_assert(offsetof(PhxDialogueSystem_StopAudioLog, InAudioLog) == 0x000000, "Member 'PhxDialogueSystem_StopAudioLog::InAudioLog' has a wrong offset!");

// Function Phoenix.PhxDialogueSystem.StopDialogue
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueSystem_StopDialogue final
{
public:
	class UDialogue*                              InDialogue;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueSystem_StopDialogue) == 0x000008, "Wrong alignment on PhxDialogueSystem_StopDialogue");
static_assert(sizeof(PhxDialogueSystem_StopDialogue) == 0x000008, "Wrong size on PhxDialogueSystem_StopDialogue");
static_assert(offsetof(PhxDialogueSystem_StopDialogue, InDialogue) == 0x000000, "Member 'PhxDialogueSystem_StopDialogue::InDialogue' has a wrong offset!");

// Function Phoenix.PhxDialogueSystem.TestCombatStateChange
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueSystem_TestCombatStateChange final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               PreviousGameState;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               NewGameState;                                      // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDialogueSystem_TestCombatStateChange) == 0x000008, "Wrong alignment on PhxDialogueSystem_TestCombatStateChange");
static_assert(sizeof(PhxDialogueSystem_TestCombatStateChange) == 0x000010, "Wrong size on PhxDialogueSystem_TestCombatStateChange");
static_assert(offsetof(PhxDialogueSystem_TestCombatStateChange, GameStateManager) == 0x000000, "Member 'PhxDialogueSystem_TestCombatStateChange::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxDialogueSystem_TestCombatStateChange, PreviousGameState) == 0x000008, "Member 'PhxDialogueSystem_TestCombatStateChange::PreviousGameState' has a wrong offset!");
static_assert(offsetof(PhxDialogueSystem_TestCombatStateChange, NewGameState) == 0x000009, "Member 'PhxDialogueSystem_TestCombatStateChange::NewGameState' has a wrong offset!");

// Function Phoenix.PhxButton.MouseClickInput
// 0x0001 (0x0001 - 0x0000)
struct PhxButton_MouseClickInput final
{
public:
	EPhxInputKeys                                 InputAction;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxButton_MouseClickInput) == 0x000001, "Wrong alignment on PhxButton_MouseClickInput");
static_assert(sizeof(PhxButton_MouseClickInput) == 0x000001, "Wrong size on PhxButton_MouseClickInput");
static_assert(offsetof(PhxButton_MouseClickInput, InputAction) == 0x000000, "Member 'PhxButton_MouseClickInput::InputAction' has a wrong offset!");

// Function Phoenix.PhxButton.MousePressInput
// 0x0002 (0x0002 - 0x0000)
struct PhxButton_MousePressInput final
{
public:
	EPhxInputKeys                                 InputAction;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsPressed;                                        // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxButton_MousePressInput) == 0x000001, "Wrong alignment on PhxButton_MousePressInput");
static_assert(sizeof(PhxButton_MousePressInput) == 0x000002, "Wrong size on PhxButton_MousePressInput");
static_assert(offsetof(PhxButton_MousePressInput, InputAction) == 0x000000, "Member 'PhxButton_MousePressInput::InputAction' has a wrong offset!");
static_assert(offsetof(PhxButton_MousePressInput, bIsPressed) == 0x000001, "Member 'PhxButton_MousePressInput::bIsPressed' has a wrong offset!");

// Function Phoenix.PhxButton.SetLabel
// 0x0018 (0x0018 - 0x0000)
struct PhxButton_SetLabel final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxButton_SetLabel) == 0x000008, "Wrong alignment on PhxButton_SetLabel");
static_assert(sizeof(PhxButton_SetLabel) == 0x000018, "Wrong size on PhxButton_SetLabel");
static_assert(offsetof(PhxButton_SetLabel, InText) == 0x000000, "Member 'PhxButton_SetLabel::InText' has a wrong offset!");

// Function Phoenix.PhxButtonWithInfo.SetInfo
// 0x0018 (0x0018 - 0x0000)
struct PhxButtonWithInfo_SetInfo final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxButtonWithInfo_SetInfo) == 0x000008, "Wrong alignment on PhxButtonWithInfo_SetInfo");
static_assert(sizeof(PhxButtonWithInfo_SetInfo) == 0x000018, "Wrong size on PhxButtonWithInfo_SetInfo");
static_assert(offsetof(PhxButtonWithInfo_SetInfo, InText) == 0x000000, "Member 'PhxButtonWithInfo_SetInfo::InText' has a wrong offset!");

// Function Phoenix.PlayerInputFSM.HandleOnHealthChanged
// 0x0028 (0x0028 - 0x0000)
struct PlayerInputFSM_HandleOnHealthChanged final
{
public:
	class UPhxHealthComponent*                    CallingHealthComp;                                 // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HealthDelta;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PlayerInputFSM_HandleOnHealthChanged) == 0x000008, "Wrong alignment on PlayerInputFSM_HandleOnHealthChanged");
static_assert(sizeof(PlayerInputFSM_HandleOnHealthChanged) == 0x000028, "Wrong size on PlayerInputFSM_HandleOnHealthChanged");
static_assert(offsetof(PlayerInputFSM_HandleOnHealthChanged, CallingHealthComp) == 0x000000, "Member 'PlayerInputFSM_HandleOnHealthChanged::CallingHealthComp' has a wrong offset!");
static_assert(offsetof(PlayerInputFSM_HandleOnHealthChanged, Health) == 0x000008, "Member 'PlayerInputFSM_HandleOnHealthChanged::Health' has a wrong offset!");
static_assert(offsetof(PlayerInputFSM_HandleOnHealthChanged, HealthDelta) == 0x00000C, "Member 'PlayerInputFSM_HandleOnHealthChanged::HealthDelta' has a wrong offset!");
static_assert(offsetof(PlayerInputFSM_HandleOnHealthChanged, DamageType) == 0x000010, "Member 'PlayerInputFSM_HandleOnHealthChanged::DamageType' has a wrong offset!");
static_assert(offsetof(PlayerInputFSM_HandleOnHealthChanged, InstigatedBy) == 0x000018, "Member 'PlayerInputFSM_HandleOnHealthChanged::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PlayerInputFSM_HandleOnHealthChanged, DamageCauser) == 0x000020, "Member 'PlayerInputFSM_HandleOnHealthChanged::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxFunicularSequenceController.OnActorBoardedStartPlatform
// 0x00A8 (0x00A8 - 0x0000)
struct PhxFunicularSequenceController_OnActorBoardedStartPlatform final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFunicularSequenceController_OnActorBoardedStartPlatform) == 0x000008, "Wrong alignment on PhxFunicularSequenceController_OnActorBoardedStartPlatform");
static_assert(sizeof(PhxFunicularSequenceController_OnActorBoardedStartPlatform) == 0x0000A8, "Wrong size on PhxFunicularSequenceController_OnActorBoardedStartPlatform");
static_assert(offsetof(PhxFunicularSequenceController_OnActorBoardedStartPlatform, OverlappedComponent) == 0x000000, "Member 'PhxFunicularSequenceController_OnActorBoardedStartPlatform::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxFunicularSequenceController_OnActorBoardedStartPlatform, OtherActor) == 0x000008, "Member 'PhxFunicularSequenceController_OnActorBoardedStartPlatform::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxFunicularSequenceController_OnActorBoardedStartPlatform, OtherComp) == 0x000010, "Member 'PhxFunicularSequenceController_OnActorBoardedStartPlatform::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxFunicularSequenceController_OnActorBoardedStartPlatform, OtherBodyIndex) == 0x000018, "Member 'PhxFunicularSequenceController_OnActorBoardedStartPlatform::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxFunicularSequenceController_OnActorBoardedStartPlatform, bFromSweep) == 0x00001C, "Member 'PhxFunicularSequenceController_OnActorBoardedStartPlatform::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxFunicularSequenceController_OnActorBoardedStartPlatform, SweepResult) == 0x000020, "Member 'PhxFunicularSequenceController_OnActorBoardedStartPlatform::SweepResult' has a wrong offset!");

// Function Phoenix.PhxFunicularSequenceController.SetSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxFunicularSequenceController_SetSpeed final
{
public:
	float                                         NewSpeed;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFunicularSequenceController_SetSpeed) == 0x000004, "Wrong alignment on PhxFunicularSequenceController_SetSpeed");
static_assert(sizeof(PhxFunicularSequenceController_SetSpeed) == 0x000004, "Wrong size on PhxFunicularSequenceController_SetSpeed");
static_assert(offsetof(PhxFunicularSequenceController_SetSpeed, NewSpeed) == 0x000000, "Member 'PhxFunicularSequenceController_SetSpeed::NewSpeed' has a wrong offset!");

// Function Phoenix.PhxFunicularSequenceController.SetTime
// 0x0004 (0x0004 - 0x0000)
struct PhxFunicularSequenceController_SetTime final
{
public:
	float                                         NewTime;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFunicularSequenceController_SetTime) == 0x000004, "Wrong alignment on PhxFunicularSequenceController_SetTime");
static_assert(sizeof(PhxFunicularSequenceController_SetTime) == 0x000004, "Wrong size on PhxFunicularSequenceController_SetTime");
static_assert(offsetof(PhxFunicularSequenceController_SetTime, NewTime) == 0x000000, "Member 'PhxFunicularSequenceController_SetTime::NewTime' has a wrong offset!");

// Function Phoenix.PhxFunicularSequenceController.GetSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxFunicularSequenceController_GetSpeed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFunicularSequenceController_GetSpeed) == 0x000004, "Wrong alignment on PhxFunicularSequenceController_GetSpeed");
static_assert(sizeof(PhxFunicularSequenceController_GetSpeed) == 0x000004, "Wrong size on PhxFunicularSequenceController_GetSpeed");
static_assert(offsetof(PhxFunicularSequenceController_GetSpeed, ReturnValue) == 0x000000, "Member 'PhxFunicularSequenceController_GetSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxFunicularSequenceController.GetTime
// 0x0004 (0x0004 - 0x0000)
struct PhxFunicularSequenceController_GetTime final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFunicularSequenceController_GetTime) == 0x000004, "Wrong alignment on PhxFunicularSequenceController_GetTime");
static_assert(sizeof(PhxFunicularSequenceController_GetTime) == 0x000004, "Wrong size on PhxFunicularSequenceController_GetTime");
static_assert(offsetof(PhxFunicularSequenceController_GetTime, ReturnValue) == 0x000000, "Member 'PhxFunicularSequenceController_GetTime::ReturnValue' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.DropBlock
// 0x0004 (0x0004 - 0x0000)
struct PPEPuzzleBlock_DropBlock final
{
public:
	int32                                         nShotPower;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEPuzzleBlock_DropBlock) == 0x000004, "Wrong alignment on PPEPuzzleBlock_DropBlock");
static_assert(sizeof(PPEPuzzleBlock_DropBlock) == 0x000004, "Wrong size on PPEPuzzleBlock_DropBlock");
static_assert(offsetof(PPEPuzzleBlock_DropBlock, nShotPower) == 0x000000, "Member 'PPEPuzzleBlock_DropBlock::nShotPower' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.GetAllBlocksAtBottom
// 0x0018 (0x0018 - 0x0000)
struct PPEPuzzleBlock_GetAllBlocksAtBottom final
{
public:
	class APPEPuzzleBlock*                        BlockToCheck;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class APPEPuzzleBlock*>                OutBottomBlockList;                                // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEPuzzleBlock_GetAllBlocksAtBottom) == 0x000008, "Wrong alignment on PPEPuzzleBlock_GetAllBlocksAtBottom");
static_assert(sizeof(PPEPuzzleBlock_GetAllBlocksAtBottom) == 0x000018, "Wrong size on PPEPuzzleBlock_GetAllBlocksAtBottom");
static_assert(offsetof(PPEPuzzleBlock_GetAllBlocksAtBottom, BlockToCheck) == 0x000000, "Member 'PPEPuzzleBlock_GetAllBlocksAtBottom::BlockToCheck' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_GetAllBlocksAtBottom, OutBottomBlockList) == 0x000008, "Member 'PPEPuzzleBlock_GetAllBlocksAtBottom::OutBottomBlockList' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.GetAllBlocksOnTop
// 0x0018 (0x0018 - 0x0000)
struct PPEPuzzleBlock_GetAllBlocksOnTop final
{
public:
	class APPEPuzzleBlock*                        BlockToCheck;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class APPEPuzzleBlock*>                OutTopBlockList;                                   // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEPuzzleBlock_GetAllBlocksOnTop) == 0x000008, "Wrong alignment on PPEPuzzleBlock_GetAllBlocksOnTop");
static_assert(sizeof(PPEPuzzleBlock_GetAllBlocksOnTop) == 0x000018, "Wrong size on PPEPuzzleBlock_GetAllBlocksOnTop");
static_assert(offsetof(PPEPuzzleBlock_GetAllBlocksOnTop, BlockToCheck) == 0x000000, "Member 'PPEPuzzleBlock_GetAllBlocksOnTop::BlockToCheck' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_GetAllBlocksOnTop, OutTopBlockList) == 0x000008, "Member 'PPEPuzzleBlock_GetAllBlocksOnTop::OutTopBlockList' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.GetPuzzleBlockMesh
// 0x0008 (0x0008 - 0x0000)
struct PPEPuzzleBlock_GetPuzzleBlockMesh final
{
public:
	class UStaticMeshComponent*                   ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEPuzzleBlock_GetPuzzleBlockMesh) == 0x000008, "Wrong alignment on PPEPuzzleBlock_GetPuzzleBlockMesh");
static_assert(sizeof(PPEPuzzleBlock_GetPuzzleBlockMesh) == 0x000008, "Wrong size on PPEPuzzleBlock_GetPuzzleBlockMesh");
static_assert(offsetof(PPEPuzzleBlock_GetPuzzleBlockMesh, ReturnValue) == 0x000000, "Member 'PPEPuzzleBlock_GetPuzzleBlockMesh::ReturnValue' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.LiftBlock
// 0x0004 (0x0004 - 0x0000)
struct PPEPuzzleBlock_LiftBlock final
{
public:
	int32                                         nShotPower;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEPuzzleBlock_LiftBlock) == 0x000004, "Wrong alignment on PPEPuzzleBlock_LiftBlock");
static_assert(sizeof(PPEPuzzleBlock_LiftBlock) == 0x000004, "Wrong size on PPEPuzzleBlock_LiftBlock");
static_assert(offsetof(PPEPuzzleBlock_LiftBlock, nShotPower) == 0x000000, "Member 'PPEPuzzleBlock_LiftBlock::nShotPower' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.OnBoxHit
// 0x00B0 (0x00B0 - 0x0000)
struct PPEPuzzleBlock_OnBoxHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PPEPuzzleBlock_OnBoxHit) == 0x000008, "Wrong alignment on PPEPuzzleBlock_OnBoxHit");
static_assert(sizeof(PPEPuzzleBlock_OnBoxHit) == 0x0000B0, "Wrong size on PPEPuzzleBlock_OnBoxHit");
static_assert(offsetof(PPEPuzzleBlock_OnBoxHit, HitComp) == 0x000000, "Member 'PPEPuzzleBlock_OnBoxHit::HitComp' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnBoxHit, OtherActor) == 0x000008, "Member 'PPEPuzzleBlock_OnBoxHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnBoxHit, OtherComp) == 0x000010, "Member 'PPEPuzzleBlock_OnBoxHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnBoxHit, NormalImpulse) == 0x000018, "Member 'PPEPuzzleBlock_OnBoxHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnBoxHit, Hit) == 0x000024, "Member 'PPEPuzzleBlock_OnBoxHit::Hit' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.OnTopBlockBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PPEPuzzleBlock_OnTopBlockBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEPuzzleBlock_OnTopBlockBeginOverlap) == 0x000008, "Wrong alignment on PPEPuzzleBlock_OnTopBlockBeginOverlap");
static_assert(sizeof(PPEPuzzleBlock_OnTopBlockBeginOverlap) == 0x0000A8, "Wrong size on PPEPuzzleBlock_OnTopBlockBeginOverlap");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockBeginOverlap, OverlappedComponent) == 0x000000, "Member 'PPEPuzzleBlock_OnTopBlockBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockBeginOverlap, OtherActor) == 0x000008, "Member 'PPEPuzzleBlock_OnTopBlockBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockBeginOverlap, OtherComp) == 0x000010, "Member 'PPEPuzzleBlock_OnTopBlockBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PPEPuzzleBlock_OnTopBlockBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockBeginOverlap, bFromSweep) == 0x00001C, "Member 'PPEPuzzleBlock_OnTopBlockBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockBeginOverlap, SweepResult) == 0x000020, "Member 'PPEPuzzleBlock_OnTopBlockBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.OnTopBlockEndOverlap
// 0x0020 (0x0020 - 0x0000)
struct PPEPuzzleBlock_OnTopBlockEndOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PPEPuzzleBlock_OnTopBlockEndOverlap) == 0x000008, "Wrong alignment on PPEPuzzleBlock_OnTopBlockEndOverlap");
static_assert(sizeof(PPEPuzzleBlock_OnTopBlockEndOverlap) == 0x000020, "Wrong size on PPEPuzzleBlock_OnTopBlockEndOverlap");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockEndOverlap, OverlappedComponent) == 0x000000, "Member 'PPEPuzzleBlock_OnTopBlockEndOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockEndOverlap, OtherActor) == 0x000008, "Member 'PPEPuzzleBlock_OnTopBlockEndOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockEndOverlap, OtherComp) == 0x000010, "Member 'PPEPuzzleBlock_OnTopBlockEndOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_OnTopBlockEndOverlap, OtherBodyIndex) == 0x000018, "Member 'PPEPuzzleBlock_OnTopBlockEndOverlap::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.PushPullBlock
// 0x0010 (0x0010 - 0x0000)
struct PPEPuzzleBlock_PushPullBlock final
{
public:
	struct FVector                                ShotDirection;                                     // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ShotPower;                                         // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEPuzzleBlock_PushPullBlock) == 0x000004, "Wrong alignment on PPEPuzzleBlock_PushPullBlock");
static_assert(sizeof(PPEPuzzleBlock_PushPullBlock) == 0x000010, "Wrong size on PPEPuzzleBlock_PushPullBlock");
static_assert(offsetof(PPEPuzzleBlock_PushPullBlock, ShotDirection) == 0x000000, "Member 'PPEPuzzleBlock_PushPullBlock::ShotDirection' has a wrong offset!");
static_assert(offsetof(PPEPuzzleBlock_PushPullBlock, ShotPower) == 0x00000C, "Member 'PPEPuzzleBlock_PushPullBlock::ShotPower' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.GetWeightLevel
// 0x0001 (0x0001 - 0x0000)
struct PPEPuzzleBlock_GetWeightLevel final
{
public:
	EWeightLevel                                  ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEPuzzleBlock_GetWeightLevel) == 0x000001, "Wrong alignment on PPEPuzzleBlock_GetWeightLevel");
static_assert(sizeof(PPEPuzzleBlock_GetWeightLevel) == 0x000001, "Wrong size on PPEPuzzleBlock_GetWeightLevel");
static_assert(offsetof(PPEPuzzleBlock_GetWeightLevel, ReturnValue) == 0x000000, "Member 'PPEPuzzleBlock_GetWeightLevel::ReturnValue' has a wrong offset!");

// Function Phoenix.PPEPuzzleBlock.GetWeightValue
// 0x0004 (0x0004 - 0x0000)
struct PPEPuzzleBlock_GetWeightValue final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEPuzzleBlock_GetWeightValue) == 0x000004, "Wrong alignment on PPEPuzzleBlock_GetWeightValue");
static_assert(sizeof(PPEPuzzleBlock_GetWeightValue) == 0x000004, "Wrong size on PPEPuzzleBlock_GetWeightValue");
static_assert(offsetof(PPEPuzzleBlock_GetWeightValue, ReturnValue) == 0x000000, "Member 'PPEPuzzleBlock_GetWeightValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHasAllOfEntitlements.HasAllOfEntitlement
// 0x0018 (0x0018 - 0x0000)
struct PhxHasAllOfEntitlements_HasAllOfEntitlement final
{
public:
	TArray<EPhxEntitlement>                       InEntitlements;                                    // 0x0000(0x0010)(Parm, ZeroConstructor, NativeAccessSpecifierPublic)
	class UPhxHasAllOfEntitlements*               ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasAllOfEntitlements_HasAllOfEntitlement) == 0x000008, "Wrong alignment on PhxHasAllOfEntitlements_HasAllOfEntitlement");
static_assert(sizeof(PhxHasAllOfEntitlements_HasAllOfEntitlement) == 0x000018, "Wrong size on PhxHasAllOfEntitlements_HasAllOfEntitlement");
static_assert(offsetof(PhxHasAllOfEntitlements_HasAllOfEntitlement, InEntitlements) == 0x000000, "Member 'PhxHasAllOfEntitlements_HasAllOfEntitlement::InEntitlements' has a wrong offset!");
static_assert(offsetof(PhxHasAllOfEntitlements_HasAllOfEntitlement, ReturnValue) == 0x000010, "Member 'PhxHasAllOfEntitlements_HasAllOfEntitlement::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHasAllOfEntitlements.HandleFetchEntitlements
// 0x0050 (0x0050 - 0x0000)
struct PhxHasAllOfEntitlements_HandleFetchEntitlements final
{
public:
	struct FPhxEntitlementOwnership               Ownership;                                         // 0x0000(0x0050)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasAllOfEntitlements_HandleFetchEntitlements) == 0x000008, "Wrong alignment on PhxHasAllOfEntitlements_HandleFetchEntitlements");
static_assert(sizeof(PhxHasAllOfEntitlements_HandleFetchEntitlements) == 0x000050, "Wrong size on PhxHasAllOfEntitlements_HandleFetchEntitlements");
static_assert(offsetof(PhxHasAllOfEntitlements_HandleFetchEntitlements, Ownership) == 0x000000, "Member 'PhxHasAllOfEntitlements_HandleFetchEntitlements::Ownership' has a wrong offset!");

// Function Phoenix.PhxHasAllOfEntitlements.HandleFetchOnlineAccount
// 0x0010 (0x0010 - 0x0000)
struct PhxHasAllOfEntitlements_HandleFetchOnlineAccount final
{
public:
	bool                                          bSuccess;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	const class USDSOnlineAccount*                OnlineAccount;                                     // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasAllOfEntitlements_HandleFetchOnlineAccount) == 0x000008, "Wrong alignment on PhxHasAllOfEntitlements_HandleFetchOnlineAccount");
static_assert(sizeof(PhxHasAllOfEntitlements_HandleFetchOnlineAccount) == 0x000010, "Wrong size on PhxHasAllOfEntitlements_HandleFetchOnlineAccount");
static_assert(offsetof(PhxHasAllOfEntitlements_HandleFetchOnlineAccount, bSuccess) == 0x000000, "Member 'PhxHasAllOfEntitlements_HandleFetchOnlineAccount::bSuccess' has a wrong offset!");
static_assert(offsetof(PhxHasAllOfEntitlements_HandleFetchOnlineAccount, OnlineAccount) == 0x000008, "Member 'PhxHasAllOfEntitlements_HandleFetchOnlineAccount::OnlineAccount' has a wrong offset!");

// Function Phoenix.PhxWorldMarkerSystem.RemoveMarker
// 0x0008 (0x0008 - 0x0000)
struct PhxWorldMarkerSystem_RemoveMarker final
{
public:
	class APhxWorldMarker*                        MarkerToRemove;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldMarkerSystem_RemoveMarker) == 0x000008, "Wrong alignment on PhxWorldMarkerSystem_RemoveMarker");
static_assert(sizeof(PhxWorldMarkerSystem_RemoveMarker) == 0x000008, "Wrong size on PhxWorldMarkerSystem_RemoveMarker");
static_assert(offsetof(PhxWorldMarkerSystem_RemoveMarker, MarkerToRemove) == 0x000000, "Member 'PhxWorldMarkerSystem_RemoveMarker::MarkerToRemove' has a wrong offset!");

// Function Phoenix.PhxWorldMarkerSystem.SpawnMarkerAtLocation
// 0x0028 (0x0028 - 0x0000)
struct PhxWorldMarkerSystem_SpawnMarkerAtLocation final
{
public:
	TSubclassOf<class APhxWorldMarker>            MarkerClass;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                TargetLocation;                                    // 0x0008(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               TargetRotation;                                    // 0x0014(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	class APhxWorldMarker*                        ReturnValue;                                       // 0x0020(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldMarkerSystem_SpawnMarkerAtLocation) == 0x000008, "Wrong alignment on PhxWorldMarkerSystem_SpawnMarkerAtLocation");
static_assert(sizeof(PhxWorldMarkerSystem_SpawnMarkerAtLocation) == 0x000028, "Wrong size on PhxWorldMarkerSystem_SpawnMarkerAtLocation");
static_assert(offsetof(PhxWorldMarkerSystem_SpawnMarkerAtLocation, MarkerClass) == 0x000000, "Member 'PhxWorldMarkerSystem_SpawnMarkerAtLocation::MarkerClass' has a wrong offset!");
static_assert(offsetof(PhxWorldMarkerSystem_SpawnMarkerAtLocation, TargetLocation) == 0x000008, "Member 'PhxWorldMarkerSystem_SpawnMarkerAtLocation::TargetLocation' has a wrong offset!");
static_assert(offsetof(PhxWorldMarkerSystem_SpawnMarkerAtLocation, TargetRotation) == 0x000014, "Member 'PhxWorldMarkerSystem_SpawnMarkerAtLocation::TargetRotation' has a wrong offset!");
static_assert(offsetof(PhxWorldMarkerSystem_SpawnMarkerAtLocation, ReturnValue) == 0x000020, "Member 'PhxWorldMarkerSystem_SpawnMarkerAtLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldMarkerSystem.SpawnMarkerOnActor
// 0x0020 (0x0020 - 0x0000)
struct PhxWorldMarkerSystem_SpawnMarkerOnActor final
{
public:
	TSubclassOf<class APhxWorldMarker>            MarkerClass;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class AActor*                           TargetActor;                                       // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Height;                                            // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class APhxWorldMarker*                        ReturnValue;                                       // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldMarkerSystem_SpawnMarkerOnActor) == 0x000008, "Wrong alignment on PhxWorldMarkerSystem_SpawnMarkerOnActor");
static_assert(sizeof(PhxWorldMarkerSystem_SpawnMarkerOnActor) == 0x000020, "Wrong size on PhxWorldMarkerSystem_SpawnMarkerOnActor");
static_assert(offsetof(PhxWorldMarkerSystem_SpawnMarkerOnActor, MarkerClass) == 0x000000, "Member 'PhxWorldMarkerSystem_SpawnMarkerOnActor::MarkerClass' has a wrong offset!");
static_assert(offsetof(PhxWorldMarkerSystem_SpawnMarkerOnActor, TargetActor) == 0x000008, "Member 'PhxWorldMarkerSystem_SpawnMarkerOnActor::TargetActor' has a wrong offset!");
static_assert(offsetof(PhxWorldMarkerSystem_SpawnMarkerOnActor, Height) == 0x000010, "Member 'PhxWorldMarkerSystem_SpawnMarkerOnActor::Height' has a wrong offset!");
static_assert(offsetof(PhxWorldMarkerSystem_SpawnMarkerOnActor, ReturnValue) == 0x000018, "Member 'PhxWorldMarkerSystem_SpawnMarkerOnActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraModifierGroup.RemoveModifier
// 0x0010 (0x0010 - 0x0000)
struct PhxCameraModifierGroup_RemoveModifier final
{
public:
	class UPhxCameraModifier*                     Modifier;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          Immediately;                                       // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0009(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCameraModifierGroup_RemoveModifier) == 0x000008, "Wrong alignment on PhxCameraModifierGroup_RemoveModifier");
static_assert(sizeof(PhxCameraModifierGroup_RemoveModifier) == 0x000010, "Wrong size on PhxCameraModifierGroup_RemoveModifier");
static_assert(offsetof(PhxCameraModifierGroup_RemoveModifier, Modifier) == 0x000000, "Member 'PhxCameraModifierGroup_RemoveModifier::Modifier' has a wrong offset!");
static_assert(offsetof(PhxCameraModifierGroup_RemoveModifier, Immediately) == 0x000008, "Member 'PhxCameraModifierGroup_RemoveModifier::Immediately' has a wrong offset!");
static_assert(offsetof(PhxCameraModifierGroup_RemoveModifier, ReturnValue) == 0x000009, "Member 'PhxCameraModifierGroup_RemoveModifier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHitmaskSpreadComponent.RenderHit
// 0x0018 (0x0018 - 0x0000)
struct PhxHitmaskSpreadComponent_RenderHit final
{
public:
	struct FVector                                Position;                                          // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BoneName;                                          // 0x000C(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHitmaskSpreadComponent_RenderHit) == 0x000004, "Wrong alignment on PhxHitmaskSpreadComponent_RenderHit");
static_assert(sizeof(PhxHitmaskSpreadComponent_RenderHit) == 0x000018, "Wrong size on PhxHitmaskSpreadComponent_RenderHit");
static_assert(offsetof(PhxHitmaskSpreadComponent_RenderHit, Position) == 0x000000, "Member 'PhxHitmaskSpreadComponent_RenderHit::Position' has a wrong offset!");
static_assert(offsetof(PhxHitmaskSpreadComponent_RenderHit, BoneName) == 0x00000C, "Member 'PhxHitmaskSpreadComponent_RenderHit::BoneName' has a wrong offset!");
static_assert(offsetof(PhxHitmaskSpreadComponent_RenderHit, Damage) == 0x000014, "Member 'PhxHitmaskSpreadComponent_RenderHit::Damage' has a wrong offset!");

// Function Phoenix.PhxInputActionMappingData.GetInputKeyList
// 0x0018 (0x0018 - 0x0000)
struct PhxInputActionMappingData_GetInputKeyList final
{
public:
	EPhxInputType                                 InType;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FKey>                           ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputActionMappingData_GetInputKeyList) == 0x000008, "Wrong alignment on PhxInputActionMappingData_GetInputKeyList");
static_assert(sizeof(PhxInputActionMappingData_GetInputKeyList) == 0x000018, "Wrong size on PhxInputActionMappingData_GetInputKeyList");
static_assert(offsetof(PhxInputActionMappingData_GetInputKeyList, InType) == 0x000000, "Member 'PhxInputActionMappingData_GetInputKeyList::InType' has a wrong offset!");
static_assert(offsetof(PhxInputActionMappingData_GetInputKeyList, ReturnValue) == 0x000008, "Member 'PhxInputActionMappingData_GetInputKeyList::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputActionMappingData.GetInputKeyForUI
// 0x0020 (0x0020 - 0x0000)
struct PhxInputActionMappingData_GetInputKeyForUI final
{
public:
	EPhxInputType                                 InType;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FKey                                   ReturnValue;                                       // 0x0008(0x0018)(Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputActionMappingData_GetInputKeyForUI) == 0x000008, "Wrong alignment on PhxInputActionMappingData_GetInputKeyForUI");
static_assert(sizeof(PhxInputActionMappingData_GetInputKeyForUI) == 0x000020, "Wrong size on PhxInputActionMappingData_GetInputKeyForUI");
static_assert(offsetof(PhxInputActionMappingData_GetInputKeyForUI, InType) == 0x000000, "Member 'PhxInputActionMappingData_GetInputKeyForUI::InType' has a wrong offset!");
static_assert(offsetof(PhxInputActionMappingData_GetInputKeyForUI, ReturnValue) == 0x000008, "Member 'PhxInputActionMappingData_GetInputKeyForUI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputActionMappingData.IsInputType
// 0x0020 (0x0020 - 0x0000)
struct PhxInputActionMappingData_IsInputType final
{
public:
	struct FKey                                   Key;                                               // 0x0000(0x0018)(ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxInputType                                 InType;                                            // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0019(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1A[0x6];                                       // 0x001A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxInputActionMappingData_IsInputType) == 0x000008, "Wrong alignment on PhxInputActionMappingData_IsInputType");
static_assert(sizeof(PhxInputActionMappingData_IsInputType) == 0x000020, "Wrong size on PhxInputActionMappingData_IsInputType");
static_assert(offsetof(PhxInputActionMappingData_IsInputType, Key) == 0x000000, "Member 'PhxInputActionMappingData_IsInputType::Key' has a wrong offset!");
static_assert(offsetof(PhxInputActionMappingData_IsInputType, InType) == 0x000018, "Member 'PhxInputActionMappingData_IsInputType::InType' has a wrong offset!");
static_assert(offsetof(PhxInputActionMappingData_IsInputType, ReturnValue) == 0x000019, "Member 'PhxInputActionMappingData_IsInputType::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraRig.LimitControlRotation
// 0x003C (0x003C - 0x0000)
struct PhxCameraRig_LimitControlRotation final
{
public:
	struct FRotator                               Rotator;                                           // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FRotator                               Against;                                           // 0x000C(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FRotator                               Minimum;                                           // 0x0018(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FRotator                               Maximum;                                           // 0x0024(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FRotator                               ReturnValue;                                       // 0x0030(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraRig_LimitControlRotation) == 0x000004, "Wrong alignment on PhxCameraRig_LimitControlRotation");
static_assert(sizeof(PhxCameraRig_LimitControlRotation) == 0x00003C, "Wrong size on PhxCameraRig_LimitControlRotation");
static_assert(offsetof(PhxCameraRig_LimitControlRotation, Rotator) == 0x000000, "Member 'PhxCameraRig_LimitControlRotation::Rotator' has a wrong offset!");
static_assert(offsetof(PhxCameraRig_LimitControlRotation, Against) == 0x00000C, "Member 'PhxCameraRig_LimitControlRotation::Against' has a wrong offset!");
static_assert(offsetof(PhxCameraRig_LimitControlRotation, Minimum) == 0x000018, "Member 'PhxCameraRig_LimitControlRotation::Minimum' has a wrong offset!");
static_assert(offsetof(PhxCameraRig_LimitControlRotation, Maximum) == 0x000024, "Member 'PhxCameraRig_LimitControlRotation::Maximum' has a wrong offset!");
static_assert(offsetof(PhxCameraRig_LimitControlRotation, ReturnValue) == 0x000030, "Member 'PhxCameraRig_LimitControlRotation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraRig.ActivateCameraGraphEntry
// 0x0038 (0x0038 - 0x0000)
struct PhxCameraRig_ActivateCameraGraphEntry final
{
public:
	struct FCameraGraphEntrySelector              TargetEntry;                                       // 0x0000(0x0030)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          Activate;                                          // 0x0030(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCameraRig_ActivateCameraGraphEntry) == 0x000008, "Wrong alignment on PhxCameraRig_ActivateCameraGraphEntry");
static_assert(sizeof(PhxCameraRig_ActivateCameraGraphEntry) == 0x000038, "Wrong size on PhxCameraRig_ActivateCameraGraphEntry");
static_assert(offsetof(PhxCameraRig_ActivateCameraGraphEntry, TargetEntry) == 0x000000, "Member 'PhxCameraRig_ActivateCameraGraphEntry::TargetEntry' has a wrong offset!");
static_assert(offsetof(PhxCameraRig_ActivateCameraGraphEntry, Activate) == 0x000030, "Member 'PhxCameraRig_ActivateCameraGraphEntry::Activate' has a wrong offset!");

// Function Phoenix.PhxCameraRig.AddModifier
// 0x0008 (0x0008 - 0x0000)
struct PhxCameraRig_AddModifier final
{
public:
	TSubclassOf<class UPhxCameraModifier>         ModfierClass;                                      // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraRig_AddModifier) == 0x000008, "Wrong alignment on PhxCameraRig_AddModifier");
static_assert(sizeof(PhxCameraRig_AddModifier) == 0x000008, "Wrong size on PhxCameraRig_AddModifier");
static_assert(offsetof(PhxCameraRig_AddModifier, ModfierClass) == 0x000000, "Member 'PhxCameraRig_AddModifier::ModfierClass' has a wrong offset!");

// Function Phoenix.PhxCameraRig.GetCameraActor
// 0x0008 (0x0008 - 0x0000)
struct PhxCameraRig_GetCameraActor final
{
public:
	class ACameraActor*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraRig_GetCameraActor) == 0x000008, "Wrong alignment on PhxCameraRig_GetCameraActor");
static_assert(sizeof(PhxCameraRig_GetCameraActor) == 0x000008, "Wrong size on PhxCameraRig_GetCameraActor");
static_assert(offsetof(PhxCameraRig_GetCameraActor, ReturnValue) == 0x000000, "Member 'PhxCameraRig_GetCameraActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraRig.GetCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxCameraRig_GetCharacter final
{
public:
	class APhxCharacter*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraRig_GetCharacter) == 0x000008, "Wrong alignment on PhxCameraRig_GetCharacter");
static_assert(sizeof(PhxCameraRig_GetCharacter) == 0x000008, "Wrong size on PhxCameraRig_GetCharacter");
static_assert(offsetof(PhxCameraRig_GetCharacter, ReturnValue) == 0x000000, "Member 'PhxCameraRig_GetCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraRig.GetMover
// 0x0008 (0x0008 - 0x0000)
struct PhxCameraRig_GetMover final
{
public:
	class UPhxCameraMover*                        ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraRig_GetMover) == 0x000008, "Wrong alignment on PhxCameraRig_GetMover");
static_assert(sizeof(PhxCameraRig_GetMover) == 0x000008, "Wrong size on PhxCameraRig_GetMover");
static_assert(offsetof(PhxCameraRig_GetMover, ReturnValue) == 0x000000, "Member 'PhxCameraRig_GetMover::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraRig.GetPhotoModeCameraActor
// 0x0008 (0x0008 - 0x0000)
struct PhxCameraRig_GetPhotoModeCameraActor final
{
public:
	class ACameraActor*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraRig_GetPhotoModeCameraActor) == 0x000008, "Wrong alignment on PhxCameraRig_GetPhotoModeCameraActor");
static_assert(sizeof(PhxCameraRig_GetPhotoModeCameraActor) == 0x000008, "Wrong size on PhxCameraRig_GetPhotoModeCameraActor");
static_assert(offsetof(PhxCameraRig_GetPhotoModeCameraActor, ReturnValue) == 0x000000, "Member 'PhxCameraRig_GetPhotoModeCameraActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraRig.IsPhotoModeMovementLocked
// 0x0001 (0x0001 - 0x0000)
struct PhxCameraRig_IsPhotoModeMovementLocked final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCameraRig_IsPhotoModeMovementLocked) == 0x000001, "Wrong alignment on PhxCameraRig_IsPhotoModeMovementLocked");
static_assert(sizeof(PhxCameraRig_IsPhotoModeMovementLocked) == 0x000001, "Wrong size on PhxCameraRig_IsPhotoModeMovementLocked");
static_assert(offsetof(PhxCameraRig_IsPhotoModeMovementLocked, ReturnValue) == 0x000000, "Member 'PhxCameraRig_IsPhotoModeMovementLocked::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCameraVolumeHandler.GetModifierProximity
// 0x0010 (0x0010 - 0x0000)
struct PhxCameraVolumeHandler_GetModifierProximity final
{
public:
	TSubclassOf<class UPhxCameraModifier>         ModifierClass;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCameraVolumeHandler_GetModifierProximity) == 0x000008, "Wrong alignment on PhxCameraVolumeHandler_GetModifierProximity");
static_assert(sizeof(PhxCameraVolumeHandler_GetModifierProximity) == 0x000010, "Wrong size on PhxCameraVolumeHandler_GetModifierProximity");
static_assert(offsetof(PhxCameraVolumeHandler_GetModifierProximity, ModifierClass) == 0x000000, "Member 'PhxCameraVolumeHandler_GetModifierProximity::ModifierClass' has a wrong offset!");
static_assert(offsetof(PhxCameraVolumeHandler_GetModifierProximity, ReturnValue) == 0x000008, "Member 'PhxCameraVolumeHandler_GetModifierProximity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCapsuleComponent.OverrideSize
// 0x000C (0x000C - 0x0000)
struct PhxCapsuleComponent_OverrideSize final
{
public:
	float                                         NewRadius;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NewHalfHeight;                                     // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InterpolateTime;                                   // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCapsuleComponent_OverrideSize) == 0x000004, "Wrong alignment on PhxCapsuleComponent_OverrideSize");
static_assert(sizeof(PhxCapsuleComponent_OverrideSize) == 0x00000C, "Wrong size on PhxCapsuleComponent_OverrideSize");
static_assert(offsetof(PhxCapsuleComponent_OverrideSize, NewRadius) == 0x000000, "Member 'PhxCapsuleComponent_OverrideSize::NewRadius' has a wrong offset!");
static_assert(offsetof(PhxCapsuleComponent_OverrideSize, NewHalfHeight) == 0x000004, "Member 'PhxCapsuleComponent_OverrideSize::NewHalfHeight' has a wrong offset!");
static_assert(offsetof(PhxCapsuleComponent_OverrideSize, InterpolateTime) == 0x000008, "Member 'PhxCapsuleComponent_OverrideSize::InterpolateTime' has a wrong offset!");

// Function Phoenix.PhxCapsuleComponent.RefreshCapsuleSize
// 0x0004 (0x0004 - 0x0000)
struct PhxCapsuleComponent_RefreshCapsuleSize final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCapsuleComponent_RefreshCapsuleSize) == 0x000004, "Wrong alignment on PhxCapsuleComponent_RefreshCapsuleSize");
static_assert(sizeof(PhxCapsuleComponent_RefreshCapsuleSize) == 0x000004, "Wrong size on PhxCapsuleComponent_RefreshCapsuleSize");
static_assert(offsetof(PhxCapsuleComponent_RefreshCapsuleSize, DeltaTime) == 0x000000, "Member 'PhxCapsuleComponent_RefreshCapsuleSize::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxCapsuleComponent.GetCharacter
// 0x0008 (0x0008 - 0x0000)
struct PhxCapsuleComponent_GetCharacter final
{
public:
	class APhxCharacter*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCapsuleComponent_GetCharacter) == 0x000008, "Wrong alignment on PhxCapsuleComponent_GetCharacter");
static_assert(sizeof(PhxCapsuleComponent_GetCharacter) == 0x000008, "Wrong size on PhxCapsuleComponent_GetCharacter");
static_assert(offsetof(PhxCapsuleComponent_GetCharacter, ReturnValue) == 0x000000, "Member 'PhxCapsuleComponent_GetCharacter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCapsuleComponent.GetDesiredSize
// 0x0008 (0x0008 - 0x0000)
struct PhxCapsuleComponent_GetDesiredSize final
{
public:
	float                                         Radius;                                            // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HalfHeight;                                        // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCapsuleComponent_GetDesiredSize) == 0x000004, "Wrong alignment on PhxCapsuleComponent_GetDesiredSize");
static_assert(sizeof(PhxCapsuleComponent_GetDesiredSize) == 0x000008, "Wrong size on PhxCapsuleComponent_GetDesiredSize");
static_assert(offsetof(PhxCapsuleComponent_GetDesiredSize, Radius) == 0x000000, "Member 'PhxCapsuleComponent_GetDesiredSize::Radius' has a wrong offset!");
static_assert(offsetof(PhxCapsuleComponent_GetDesiredSize, HalfHeight) == 0x000004, "Member 'PhxCapsuleComponent_GetDesiredSize::HalfHeight' has a wrong offset!");

// Function Phoenix.PhxCarouselComponent.GetRotationStep
// 0x0004 (0x0004 - 0x0000)
struct PhxCarouselComponent_GetRotationStep final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCarouselComponent_GetRotationStep) == 0x000004, "Wrong alignment on PhxCarouselComponent_GetRotationStep");
static_assert(sizeof(PhxCarouselComponent_GetRotationStep) == 0x000004, "Wrong size on PhxCarouselComponent_GetRotationStep");
static_assert(offsetof(PhxCarouselComponent_GetRotationStep, ReturnValue) == 0x000000, "Member 'PhxCarouselComponent_GetRotationStep::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCatwalkClimbActor.OnEntryInteractionExecuted
// 0x0008 (0x0008 - 0x0000)
struct PhxCatwalkClimbActor_OnEntryInteractionExecuted final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCatwalkClimbActor_OnEntryInteractionExecuted) == 0x000008, "Wrong alignment on PhxCatwalkClimbActor_OnEntryInteractionExecuted");
static_assert(sizeof(PhxCatwalkClimbActor_OnEntryInteractionExecuted) == 0x000008, "Wrong size on PhxCatwalkClimbActor_OnEntryInteractionExecuted");
static_assert(offsetof(PhxCatwalkClimbActor_OnEntryInteractionExecuted, InteractedBy) == 0x000000, "Member 'PhxCatwalkClimbActor_OnEntryInteractionExecuted::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxCatwalkClimbActor.OnEntryInteractionInitialized
// 0x0008 (0x0008 - 0x0000)
struct PhxCatwalkClimbActor_OnEntryInteractionInitialized final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCatwalkClimbActor_OnEntryInteractionInitialized) == 0x000008, "Wrong alignment on PhxCatwalkClimbActor_OnEntryInteractionInitialized");
static_assert(sizeof(PhxCatwalkClimbActor_OnEntryInteractionInitialized) == 0x000008, "Wrong size on PhxCatwalkClimbActor_OnEntryInteractionInitialized");
static_assert(offsetof(PhxCatwalkClimbActor_OnEntryInteractionInitialized, InteractedBy) == 0x000000, "Member 'PhxCatwalkClimbActor_OnEntryInteractionInitialized::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.RegisterBodyPartMutationMap
// 0x0028 (0x0028 - 0x0000)
struct PhxCharacterGoreComponent_RegisterBodyPartMutationMap final
{
public:
	EPhxBodyPartType                              BodyPartType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPhxMutatedBodyPart                    BodyPartMutationMeshes;                            // 0x0008(0x0020)(Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_RegisterBodyPartMutationMap) == 0x000008, "Wrong alignment on PhxCharacterGoreComponent_RegisterBodyPartMutationMap");
static_assert(sizeof(PhxCharacterGoreComponent_RegisterBodyPartMutationMap) == 0x000028, "Wrong size on PhxCharacterGoreComponent_RegisterBodyPartMutationMap");
static_assert(offsetof(PhxCharacterGoreComponent_RegisterBodyPartMutationMap, BodyPartType) == 0x000000, "Member 'PhxCharacterGoreComponent_RegisterBodyPartMutationMap::BodyPartType' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_RegisterBodyPartMutationMap, BodyPartMutationMeshes) == 0x000008, "Member 'PhxCharacterGoreComponent_RegisterBodyPartMutationMap::BodyPartMutationMeshes' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.RegisterExplicitGoreCapComponent
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent final
{
public:
	EPhxBodyPartType                              BodyPartType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeletalMeshComponent*                 SkeletalMeshComponent;                             // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent) == 0x000008, "Wrong alignment on PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent");
static_assert(sizeof(PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent) == 0x000010, "Wrong size on PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent");
static_assert(offsetof(PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent, BodyPartType) == 0x000000, "Member 'PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent::BodyPartType' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent, SkeletalMeshComponent) == 0x000008, "Member 'PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent::SkeletalMeshComponent' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.RegisterGoreSkeletalMeshComponents
// 0x0050 (0x0050 - 0x0000)
struct PhxCharacterGoreComponent_RegisterGoreSkeletalMeshComponents final
{
public:
	struct FPhxGoreSkeletalMeshesInfo             GoreMeshesInfo;                                    // 0x0000(0x0050)(ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_RegisterGoreSkeletalMeshComponents) == 0x000008, "Wrong alignment on PhxCharacterGoreComponent_RegisterGoreSkeletalMeshComponents");
static_assert(sizeof(PhxCharacterGoreComponent_RegisterGoreSkeletalMeshComponents) == 0x000050, "Wrong size on PhxCharacterGoreComponent_RegisterGoreSkeletalMeshComponents");
static_assert(offsetof(PhxCharacterGoreComponent_RegisterGoreSkeletalMeshComponents, GoreMeshesInfo) == 0x000000, "Member 'PhxCharacterGoreComponent_RegisterGoreSkeletalMeshComponents::GoreMeshesInfo' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.RegisterPristineSkeletalMeshComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterGoreComponent_RegisterPristineSkeletalMeshComponent final
{
public:
	class USkeletalMeshComponent*                 PristineMesh;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_RegisterPristineSkeletalMeshComponent) == 0x000008, "Wrong alignment on PhxCharacterGoreComponent_RegisterPristineSkeletalMeshComponent");
static_assert(sizeof(PhxCharacterGoreComponent_RegisterPristineSkeletalMeshComponent) == 0x000008, "Wrong size on PhxCharacterGoreComponent_RegisterPristineSkeletalMeshComponent");
static_assert(offsetof(PhxCharacterGoreComponent_RegisterPristineSkeletalMeshComponent, PristineMesh) == 0x000000, "Member 'PhxCharacterGoreComponent_RegisterPristineSkeletalMeshComponent::PristineMesh' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.RegisterSkeletalMeshCompnent
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent final
{
public:
	EPhxBodyPartType                              BodyPartType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeletalMeshComponent*                 SkeletalMeshComponent;                             // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent) == 0x000008, "Wrong alignment on PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent");
static_assert(sizeof(PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent) == 0x000010, "Wrong size on PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent");
static_assert(offsetof(PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent, BodyPartType) == 0x000000, "Member 'PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent::BodyPartType' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent, SkeletalMeshComponent) == 0x000008, "Member 'PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent::SkeletalMeshComponent' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.TEST_GetBodyPartHealth
// 0x000C (0x000C - 0x0000)
struct PhxCharacterGoreComponent_TEST_GetBodyPartHealth final
{
public:
	class FName                                   BoneName;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_TEST_GetBodyPartHealth) == 0x000004, "Wrong alignment on PhxCharacterGoreComponent_TEST_GetBodyPartHealth");
static_assert(sizeof(PhxCharacterGoreComponent_TEST_GetBodyPartHealth) == 0x00000C, "Wrong size on PhxCharacterGoreComponent_TEST_GetBodyPartHealth");
static_assert(offsetof(PhxCharacterGoreComponent_TEST_GetBodyPartHealth, BoneName) == 0x000000, "Member 'PhxCharacterGoreComponent_TEST_GetBodyPartHealth::BoneName' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_TEST_GetBodyPartHealth, ReturnValue) == 0x000008, "Member 'PhxCharacterGoreComponent_TEST_GetBodyPartHealth::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.TEST_SetBodyPartHealth
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterGoreComponent_TEST_SetBodyPartHealth final
{
public:
	class FName                                   BoneName;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x000C(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterGoreComponent_TEST_SetBodyPartHealth) == 0x000004, "Wrong alignment on PhxCharacterGoreComponent_TEST_SetBodyPartHealth");
static_assert(sizeof(PhxCharacterGoreComponent_TEST_SetBodyPartHealth) == 0x000010, "Wrong size on PhxCharacterGoreComponent_TEST_SetBodyPartHealth");
static_assert(offsetof(PhxCharacterGoreComponent_TEST_SetBodyPartHealth, BoneName) == 0x000000, "Member 'PhxCharacterGoreComponent_TEST_SetBodyPartHealth::BoneName' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_TEST_SetBodyPartHealth, Health) == 0x000008, "Member 'PhxCharacterGoreComponent_TEST_SetBodyPartHealth::Health' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_TEST_SetBodyPartHealth, ReturnValue) == 0x00000C, "Member 'PhxCharacterGoreComponent_TEST_SetBodyPartHealth::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.TryAutoDismemberBodyPart
// 0x0028 (0x0028 - 0x0000)
struct PhxCharacterGoreComponent_TryAutoDismemberBodyPart final
{
public:
	class FName                                   BoneName;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EUntaggedWoundType                            GoreType;                                          // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                ImpactDirection;                                   // 0x000C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class ULimbDetatchmentBehaviorBase> PreferredDetatchmentBehavior;                    // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0020(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x7];                                       // 0x0021(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterGoreComponent_TryAutoDismemberBodyPart) == 0x000008, "Wrong alignment on PhxCharacterGoreComponent_TryAutoDismemberBodyPart");
static_assert(sizeof(PhxCharacterGoreComponent_TryAutoDismemberBodyPart) == 0x000028, "Wrong size on PhxCharacterGoreComponent_TryAutoDismemberBodyPart");
static_assert(offsetof(PhxCharacterGoreComponent_TryAutoDismemberBodyPart, BoneName) == 0x000000, "Member 'PhxCharacterGoreComponent_TryAutoDismemberBodyPart::BoneName' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_TryAutoDismemberBodyPart, GoreType) == 0x000008, "Member 'PhxCharacterGoreComponent_TryAutoDismemberBodyPart::GoreType' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_TryAutoDismemberBodyPart, ImpactDirection) == 0x00000C, "Member 'PhxCharacterGoreComponent_TryAutoDismemberBodyPart::ImpactDirection' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_TryAutoDismemberBodyPart, PreferredDetatchmentBehavior) == 0x000018, "Member 'PhxCharacterGoreComponent_TryAutoDismemberBodyPart::PreferredDetatchmentBehavior' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_TryAutoDismemberBodyPart, ReturnValue) == 0x000020, "Member 'PhxCharacterGoreComponent_TryAutoDismemberBodyPart::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.TrySwapPristineMeshes
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterGoreComponent_TrySwapPristineMeshes final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_TrySwapPristineMeshes) == 0x000001, "Wrong alignment on PhxCharacterGoreComponent_TrySwapPristineMeshes");
static_assert(sizeof(PhxCharacterGoreComponent_TrySwapPristineMeshes) == 0x000001, "Wrong size on PhxCharacterGoreComponent_TrySwapPristineMeshes");
static_assert(offsetof(PhxCharacterGoreComponent_TrySwapPristineMeshes, ReturnValue) == 0x000000, "Member 'PhxCharacterGoreComponent_TrySwapPristineMeshes::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.GetBodyPartHealth
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterGoreComponent_GetBodyPartHealth final
{
public:
	EPhxBodyPartType                              BodyPart;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_GetBodyPartHealth) == 0x000004, "Wrong alignment on PhxCharacterGoreComponent_GetBodyPartHealth");
static_assert(sizeof(PhxCharacterGoreComponent_GetBodyPartHealth) == 0x000008, "Wrong size on PhxCharacterGoreComponent_GetBodyPartHealth");
static_assert(offsetof(PhxCharacterGoreComponent_GetBodyPartHealth, BodyPart) == 0x000000, "Member 'PhxCharacterGoreComponent_GetBodyPartHealth::BodyPart' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_GetBodyPartHealth, ReturnValue) == 0x000004, "Member 'PhxCharacterGoreComponent_GetBodyPartHealth::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.GetBodyPartHealthPercent
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterGoreComponent_GetBodyPartHealthPercent final
{
public:
	EPhxBodyPartType                              BodyPart;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_GetBodyPartHealthPercent) == 0x000004, "Wrong alignment on PhxCharacterGoreComponent_GetBodyPartHealthPercent");
static_assert(sizeof(PhxCharacterGoreComponent_GetBodyPartHealthPercent) == 0x000008, "Wrong size on PhxCharacterGoreComponent_GetBodyPartHealthPercent");
static_assert(offsetof(PhxCharacterGoreComponent_GetBodyPartHealthPercent, BodyPart) == 0x000000, "Member 'PhxCharacterGoreComponent_GetBodyPartHealthPercent::BodyPart' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_GetBodyPartHealthPercent, ReturnValue) == 0x000004, "Member 'PhxCharacterGoreComponent_GetBodyPartHealthPercent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterGoreComponent.GetBodyPartMaxHealth
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterGoreComponent_GetBodyPartMaxHealth final
{
public:
	EPhxBodyPartType                              BodyPart;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterGoreComponent_GetBodyPartMaxHealth) == 0x000004, "Wrong alignment on PhxCharacterGoreComponent_GetBodyPartMaxHealth");
static_assert(sizeof(PhxCharacterGoreComponent_GetBodyPartMaxHealth) == 0x000008, "Wrong size on PhxCharacterGoreComponent_GetBodyPartMaxHealth");
static_assert(offsetof(PhxCharacterGoreComponent_GetBodyPartMaxHealth, BodyPart) == 0x000000, "Member 'PhxCharacterGoreComponent_GetBodyPartMaxHealth::BodyPart' has a wrong offset!");
static_assert(offsetof(PhxCharacterGoreComponent_GetBodyPartMaxHealth, ReturnValue) == 0x000004, "Member 'PhxCharacterGoreComponent_GetBodyPartMaxHealth::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHealthComponent.HandleTakeAnyDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxHealthComponent_HandleTakeAnyDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHealthComponent_HandleTakeAnyDamage) == 0x000008, "Wrong alignment on PhxHealthComponent_HandleTakeAnyDamage");
static_assert(sizeof(PhxHealthComponent_HandleTakeAnyDamage) == 0x000028, "Wrong size on PhxHealthComponent_HandleTakeAnyDamage");
static_assert(offsetof(PhxHealthComponent_HandleTakeAnyDamage, DamagedActor) == 0x000000, "Member 'PhxHealthComponent_HandleTakeAnyDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_HandleTakeAnyDamage, Damage) == 0x000008, "Member 'PhxHealthComponent_HandleTakeAnyDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_HandleTakeAnyDamage, DamageType) == 0x000010, "Member 'PhxHealthComponent_HandleTakeAnyDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_HandleTakeAnyDamage, InstigatedBy) == 0x000018, "Member 'PhxHealthComponent_HandleTakeAnyDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_HandleTakeAnyDamage, DamageCauser) == 0x000020, "Member 'PhxHealthComponent_HandleTakeAnyDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxHealthComponent.Heal
// 0x0020 (0x0020 - 0x0000)
struct PhxHealthComponent_Heal final
{
public:
	float                                         HealAmount;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      HealType;                                          // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 HealCauser;                                        // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHealthComponent_Heal) == 0x000008, "Wrong alignment on PhxHealthComponent_Heal");
static_assert(sizeof(PhxHealthComponent_Heal) == 0x000020, "Wrong size on PhxHealthComponent_Heal");
static_assert(offsetof(PhxHealthComponent_Heal, HealAmount) == 0x000000, "Member 'PhxHealthComponent_Heal::HealAmount' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_Heal, HealType) == 0x000008, "Member 'PhxHealthComponent_Heal::HealType' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_Heal, InstigatedBy) == 0x000010, "Member 'PhxHealthComponent_Heal::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_Heal, HealCauser) == 0x000018, "Member 'PhxHealthComponent_Heal::HealCauser' has a wrong offset!");

// Function Phoenix.PhxHealthComponent.Kill
// 0x0010 (0x0010 - 0x0000)
struct PhxHealthComponent_Kill final
{
public:
	class AActor*                                 DamageCauser;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UDamageType>                DamageType;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHealthComponent_Kill) == 0x000008, "Wrong alignment on PhxHealthComponent_Kill");
static_assert(sizeof(PhxHealthComponent_Kill) == 0x000010, "Wrong size on PhxHealthComponent_Kill");
static_assert(offsetof(PhxHealthComponent_Kill, DamageCauser) == 0x000000, "Member 'PhxHealthComponent_Kill::DamageCauser' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_Kill, DamageType) == 0x000008, "Member 'PhxHealthComponent_Kill::DamageType' has a wrong offset!");

// Function Phoenix.PhxHealthComponent.SetHealthPct
// 0x0020 (0x0020 - 0x0000)
struct PhxHealthComponent_SetHealthPct final
{
public:
	float                                         NewHealthPct;                                      // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHealthComponent_SetHealthPct) == 0x000008, "Wrong alignment on PhxHealthComponent_SetHealthPct");
static_assert(sizeof(PhxHealthComponent_SetHealthPct) == 0x000020, "Wrong size on PhxHealthComponent_SetHealthPct");
static_assert(offsetof(PhxHealthComponent_SetHealthPct, NewHealthPct) == 0x000000, "Member 'PhxHealthComponent_SetHealthPct::NewHealthPct' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_SetHealthPct, DamageType) == 0x000008, "Member 'PhxHealthComponent_SetHealthPct::DamageType' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_SetHealthPct, InstigatedBy) == 0x000010, "Member 'PhxHealthComponent_SetHealthPct::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxHealthComponent_SetHealthPct, DamageCauser) == 0x000018, "Member 'PhxHealthComponent_SetHealthPct::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxHealthComponent.GetHealth
// 0x0004 (0x0004 - 0x0000)
struct PhxHealthComponent_GetHealth final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHealthComponent_GetHealth) == 0x000004, "Wrong alignment on PhxHealthComponent_GetHealth");
static_assert(sizeof(PhxHealthComponent_GetHealth) == 0x000004, "Wrong size on PhxHealthComponent_GetHealth");
static_assert(offsetof(PhxHealthComponent_GetHealth, ReturnValue) == 0x000000, "Member 'PhxHealthComponent_GetHealth::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHealthComponent.GetHealthPercent
// 0x0004 (0x0004 - 0x0000)
struct PhxHealthComponent_GetHealthPercent final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHealthComponent_GetHealthPercent) == 0x000004, "Wrong alignment on PhxHealthComponent_GetHealthPercent");
static_assert(sizeof(PhxHealthComponent_GetHealthPercent) == 0x000004, "Wrong size on PhxHealthComponent_GetHealthPercent");
static_assert(offsetof(PhxHealthComponent_GetHealthPercent, ReturnValue) == 0x000000, "Member 'PhxHealthComponent_GetHealthPercent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHealthComponent.IsAlive
// 0x0001 (0x0001 - 0x0000)
struct PhxHealthComponent_IsAlive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHealthComponent_IsAlive) == 0x000001, "Wrong alignment on PhxHealthComponent_IsAlive");
static_assert(sizeof(PhxHealthComponent_IsAlive) == 0x000001, "Wrong size on PhxHealthComponent_IsAlive");
static_assert(offsetof(PhxHealthComponent_IsAlive, ReturnValue) == 0x000000, "Member 'PhxHealthComponent_IsAlive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthComponent.EndStopBarOnDeath
// 0x0020 (0x0020 - 0x0000)
struct PhxCharacterHealthComponent_EndStopBarOnDeath final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterHealthComponent_EndStopBarOnDeath) == 0x000008, "Wrong alignment on PhxCharacterHealthComponent_EndStopBarOnDeath");
static_assert(sizeof(PhxCharacterHealthComponent_EndStopBarOnDeath) == 0x000020, "Wrong size on PhxCharacterHealthComponent_EndStopBarOnDeath");
static_assert(offsetof(PhxCharacterHealthComponent_EndStopBarOnDeath, DeadCharacter) == 0x000000, "Member 'PhxCharacterHealthComponent_EndStopBarOnDeath::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthComponent_EndStopBarOnDeath, KillerActor) == 0x000008, "Member 'PhxCharacterHealthComponent_EndStopBarOnDeath::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthComponent_EndStopBarOnDeath, KillerController) == 0x000010, "Member 'PhxCharacterHealthComponent_EndStopBarOnDeath::KillerController' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthComponent_EndStopBarOnDeath, KillingBlowHealthDelta) == 0x000018, "Member 'PhxCharacterHealthComponent_EndStopBarOnDeath::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthComponent.ReceiveFakeHit
// 0x0030 (0x0030 - 0x0000)
struct PhxCharacterHealthComponent_ReceiveFakeHit final
{
public:
	struct FVector                                Location;                                          // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                Direction;                                         // 0x000C(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BoneName;                                          // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UDamageType>                DamageType;                                        // 0x0028(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthComponent_ReceiveFakeHit) == 0x000008, "Wrong alignment on PhxCharacterHealthComponent_ReceiveFakeHit");
static_assert(sizeof(PhxCharacterHealthComponent_ReceiveFakeHit) == 0x000030, "Wrong size on PhxCharacterHealthComponent_ReceiveFakeHit");
static_assert(offsetof(PhxCharacterHealthComponent_ReceiveFakeHit, Location) == 0x000000, "Member 'PhxCharacterHealthComponent_ReceiveFakeHit::Location' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthComponent_ReceiveFakeHit, Direction) == 0x00000C, "Member 'PhxCharacterHealthComponent_ReceiveFakeHit::Direction' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthComponent_ReceiveFakeHit, BoneName) == 0x000018, "Member 'PhxCharacterHealthComponent_ReceiveFakeHit::BoneName' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthComponent_ReceiveFakeHit, Damage) == 0x000020, "Member 'PhxCharacterHealthComponent_ReceiveFakeHit::Damage' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthComponent_ReceiveFakeHit, DamageType) == 0x000028, "Member 'PhxCharacterHealthComponent_ReceiveFakeHit::DamageType' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthComponent.StoppingPowerBarUpdate
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterHealthComponent_StoppingPowerBarUpdate final
{
public:
	float                                         StopPower;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultStopPower;                                  // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthComponent_StoppingPowerBarUpdate) == 0x000004, "Wrong alignment on PhxCharacterHealthComponent_StoppingPowerBarUpdate");
static_assert(sizeof(PhxCharacterHealthComponent_StoppingPowerBarUpdate) == 0x000008, "Wrong size on PhxCharacterHealthComponent_StoppingPowerBarUpdate");
static_assert(offsetof(PhxCharacterHealthComponent_StoppingPowerBarUpdate, StopPower) == 0x000000, "Member 'PhxCharacterHealthComponent_StoppingPowerBarUpdate::StopPower' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthComponent_StoppingPowerBarUpdate, DefaultStopPower) == 0x000004, "Member 'PhxCharacterHealthComponent_StoppingPowerBarUpdate::DefaultStopPower' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthComponent.IsInjured
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterHealthComponent_IsInjured final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthComponent_IsInjured) == 0x000001, "Wrong alignment on PhxCharacterHealthComponent_IsInjured");
static_assert(sizeof(PhxCharacterHealthComponent_IsInjured) == 0x000001, "Wrong size on PhxCharacterHealthComponent_IsInjured");
static_assert(offsetof(PhxCharacterHealthComponent_IsInjured, ReturnValue) == 0x000000, "Member 'PhxCharacterHealthComponent_IsInjured::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthMeterComponent.OnDialogLineEnded
// 0x0098 (0x0098 - 0x0000)
struct PhxCharacterHealthMeterComponent_OnDialogLineEnded final
{
public:
	class AActor*                                 SpeakingActor;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FDialogueNode                          DialogueNode;                                      // 0x0008(0x0090)(Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthMeterComponent_OnDialogLineEnded) == 0x000008, "Wrong alignment on PhxCharacterHealthMeterComponent_OnDialogLineEnded");
static_assert(sizeof(PhxCharacterHealthMeterComponent_OnDialogLineEnded) == 0x000098, "Wrong size on PhxCharacterHealthMeterComponent_OnDialogLineEnded");
static_assert(offsetof(PhxCharacterHealthMeterComponent_OnDialogLineEnded, SpeakingActor) == 0x000000, "Member 'PhxCharacterHealthMeterComponent_OnDialogLineEnded::SpeakingActor' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthMeterComponent_OnDialogLineEnded, DialogueNode) == 0x000008, "Member 'PhxCharacterHealthMeterComponent_OnDialogLineEnded::DialogueNode' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthMeterComponent.OnDialogLineStarted
// 0x0098 (0x0098 - 0x0000)
struct PhxCharacterHealthMeterComponent_OnDialogLineStarted final
{
public:
	class AActor*                                 SpeakingActor;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FDialogueNode                          DialogueNode;                                      // 0x0008(0x0090)(Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthMeterComponent_OnDialogLineStarted) == 0x000008, "Wrong alignment on PhxCharacterHealthMeterComponent_OnDialogLineStarted");
static_assert(sizeof(PhxCharacterHealthMeterComponent_OnDialogLineStarted) == 0x000098, "Wrong size on PhxCharacterHealthMeterComponent_OnDialogLineStarted");
static_assert(offsetof(PhxCharacterHealthMeterComponent_OnDialogLineStarted, SpeakingActor) == 0x000000, "Member 'PhxCharacterHealthMeterComponent_OnDialogLineStarted::SpeakingActor' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthMeterComponent_OnDialogLineStarted, DialogueNode) == 0x000008, "Member 'PhxCharacterHealthMeterComponent_OnDialogLineStarted::DialogueNode' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthMeterComponent.OnNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterHealthMeterComponent_OnNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthMeterComponent_OnNotifyReceived) == 0x000008, "Wrong alignment on PhxCharacterHealthMeterComponent_OnNotifyReceived");
static_assert(sizeof(PhxCharacterHealthMeterComponent_OnNotifyReceived) == 0x000008, "Wrong size on PhxCharacterHealthMeterComponent_OnNotifyReceived");
static_assert(offsetof(PhxCharacterHealthMeterComponent_OnNotifyReceived, Notify) == 0x000000, "Member 'PhxCharacterHealthMeterComponent_OnNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthMeterComponent.PlayCircuitEffect
// 0x0028 (0x0028 - 0x0000)
struct PhxCharacterHealthMeterComponent_PlayCircuitEffect final
{
public:
	struct FCircuitEffectParameters               EffectParams;                                      // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthMeterComponent_PlayCircuitEffect) == 0x000004, "Wrong alignment on PhxCharacterHealthMeterComponent_PlayCircuitEffect");
static_assert(sizeof(PhxCharacterHealthMeterComponent_PlayCircuitEffect) == 0x000028, "Wrong size on PhxCharacterHealthMeterComponent_PlayCircuitEffect");
static_assert(offsetof(PhxCharacterHealthMeterComponent_PlayCircuitEffect, EffectParams) == 0x000000, "Member 'PhxCharacterHealthMeterComponent_PlayCircuitEffect::EffectParams' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthMeterComponent.PlayEdgeGlowEffect
// 0x004C (0x004C - 0x0000)
struct PhxCharacterHealthMeterComponent_PlayEdgeGlowEffect final
{
public:
	struct FEdgeGlowEffectParameters              EffectParams;                                      // 0x0000(0x004C)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthMeterComponent_PlayEdgeGlowEffect) == 0x000004, "Wrong alignment on PhxCharacterHealthMeterComponent_PlayEdgeGlowEffect");
static_assert(sizeof(PhxCharacterHealthMeterComponent_PlayEdgeGlowEffect) == 0x00004C, "Wrong size on PhxCharacterHealthMeterComponent_PlayEdgeGlowEffect");
static_assert(offsetof(PhxCharacterHealthMeterComponent_PlayEdgeGlowEffect, EffectParams) == 0x000000, "Member 'PhxCharacterHealthMeterComponent_PlayEdgeGlowEffect::EffectParams' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthMeterComponent.PlayFlashEffect
// 0x0024 (0x0024 - 0x0000)
struct PhxCharacterHealthMeterComponent_PlayFlashEffect final
{
public:
	struct FFlashEffectParameters                 EffectParams;                                      // 0x0000(0x0024)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthMeterComponent_PlayFlashEffect) == 0x000004, "Wrong alignment on PhxCharacterHealthMeterComponent_PlayFlashEffect");
static_assert(sizeof(PhxCharacterHealthMeterComponent_PlayFlashEffect) == 0x000024, "Wrong size on PhxCharacterHealthMeterComponent_PlayFlashEffect");
static_assert(offsetof(PhxCharacterHealthMeterComponent_PlayFlashEffect, EffectParams) == 0x000000, "Member 'PhxCharacterHealthMeterComponent_PlayFlashEffect::EffectParams' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthMeterComponent.PlayOutlineEffect
// 0x0024 (0x0024 - 0x0000)
struct PhxCharacterHealthMeterComponent_PlayOutlineEffect final
{
public:
	struct FOutlineEffectParameters               EffectParams;                                      // 0x0000(0x0024)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthMeterComponent_PlayOutlineEffect) == 0x000004, "Wrong alignment on PhxCharacterHealthMeterComponent_PlayOutlineEffect");
static_assert(sizeof(PhxCharacterHealthMeterComponent_PlayOutlineEffect) == 0x000024, "Wrong size on PhxCharacterHealthMeterComponent_PlayOutlineEffect");
static_assert(offsetof(PhxCharacterHealthMeterComponent_PlayOutlineEffect, EffectParams) == 0x000000, "Member 'PhxCharacterHealthMeterComponent_PlayOutlineEffect::EffectParams' has a wrong offset!");

// Function Phoenix.PhxCharacterHealthMeterComponent.ReactToHealthChange
// 0x0028 (0x0028 - 0x0000)
struct PhxCharacterHealthMeterComponent_ReactToHealthChange final
{
public:
	class UPhxHealthComponent*                    InHealthComp;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HealthDelta;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHealthMeterComponent_ReactToHealthChange) == 0x000008, "Wrong alignment on PhxCharacterHealthMeterComponent_ReactToHealthChange");
static_assert(sizeof(PhxCharacterHealthMeterComponent_ReactToHealthChange) == 0x000028, "Wrong size on PhxCharacterHealthMeterComponent_ReactToHealthChange");
static_assert(offsetof(PhxCharacterHealthMeterComponent_ReactToHealthChange, InHealthComp) == 0x000000, "Member 'PhxCharacterHealthMeterComponent_ReactToHealthChange::InHealthComp' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthMeterComponent_ReactToHealthChange, Health) == 0x000008, "Member 'PhxCharacterHealthMeterComponent_ReactToHealthChange::Health' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthMeterComponent_ReactToHealthChange, HealthDelta) == 0x00000C, "Member 'PhxCharacterHealthMeterComponent_ReactToHealthChange::HealthDelta' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthMeterComponent_ReactToHealthChange, DamageType) == 0x000010, "Member 'PhxCharacterHealthMeterComponent_ReactToHealthChange::DamageType' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthMeterComponent_ReactToHealthChange, InstigatedBy) == 0x000018, "Member 'PhxCharacterHealthMeterComponent_ReactToHealthChange::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxCharacterHealthMeterComponent_ReactToHealthChange, DamageCauser) == 0x000020, "Member 'PhxCharacterHealthMeterComponent_ReactToHealthChange::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxCharacterHeartbeatComponent.OnModifierTagAddedOrRemoved
// 0x000C (0x000C - 0x0000)
struct PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved final
{
public:
	struct FGameplayTag                           Tag;                                               // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Count;                                             // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved) == 0x000004, "Wrong alignment on PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved");
static_assert(sizeof(PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved) == 0x00000C, "Wrong size on PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved");
static_assert(offsetof(PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved, Tag) == 0x000000, "Member 'PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved::Tag' has a wrong offset!");
static_assert(offsetof(PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved, Count) == 0x000008, "Member 'PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved::Count' has a wrong offset!");

// Function Phoenix.PhxCharacterHeartbeatComponent.GetCurrentHeartRate
// 0x0004 (0x0004 - 0x0000)
struct PhxCharacterHeartbeatComponent_GetCurrentHeartRate final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHeartbeatComponent_GetCurrentHeartRate) == 0x000004, "Wrong alignment on PhxCharacterHeartbeatComponent_GetCurrentHeartRate");
static_assert(sizeof(PhxCharacterHeartbeatComponent_GetCurrentHeartRate) == 0x000004, "Wrong size on PhxCharacterHeartbeatComponent_GetCurrentHeartRate");
static_assert(offsetof(PhxCharacterHeartbeatComponent_GetCurrentHeartRate, ReturnValue) == 0x000000, "Member 'PhxCharacterHeartbeatComponent_GetCurrentHeartRate::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterHeartbeatComponent.GetNormalizedHeartRate
// 0x0004 (0x0004 - 0x0000)
struct PhxCharacterHeartbeatComponent_GetNormalizedHeartRate final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterHeartbeatComponent_GetNormalizedHeartRate) == 0x000004, "Wrong alignment on PhxCharacterHeartbeatComponent_GetNormalizedHeartRate");
static_assert(sizeof(PhxCharacterHeartbeatComponent_GetNormalizedHeartRate) == 0x000004, "Wrong size on PhxCharacterHeartbeatComponent_GetNormalizedHeartRate");
static_assert(offsetof(PhxCharacterHeartbeatComponent_GetNormalizedHeartRate, ReturnValue) == 0x000000, "Member 'PhxCharacterHeartbeatComponent_GetNormalizedHeartRate::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.AddItemData
// 0x0108 (0x0108 - 0x0000)
struct PhxCharacterInventoryComponent_AddItemData final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          bShowNotification;                                 // 0x0100(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bOverrideAmount;                                   // 0x0101(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_102[0x2];                                      // 0x0102(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         Amount;                                            // 0x0104(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_AddItemData) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_AddItemData");
static_assert(sizeof(PhxCharacterInventoryComponent_AddItemData) == 0x000108, "Wrong size on PhxCharacterInventoryComponent_AddItemData");
static_assert(offsetof(PhxCharacterInventoryComponent_AddItemData, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_AddItemData::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_AddItemData, bShowNotification) == 0x000100, "Member 'PhxCharacterInventoryComponent_AddItemData::bShowNotification' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_AddItemData, bOverrideAmount) == 0x000101, "Member 'PhxCharacterInventoryComponent_AddItemData::bOverrideAmount' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_AddItemData, Amount) == 0x000104, "Member 'PhxCharacterInventoryComponent_AddItemData::Amount' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.AddItemDataByName
// 0x000C (0x000C - 0x0000)
struct PhxCharacterInventoryComponent_AddItemDataByName final
{
public:
	class FName                                   ItemName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Amount;                                            // 0x0008(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_AddItemDataByName) == 0x000004, "Wrong alignment on PhxCharacterInventoryComponent_AddItemDataByName");
static_assert(sizeof(PhxCharacterInventoryComponent_AddItemDataByName) == 0x00000C, "Wrong size on PhxCharacterInventoryComponent_AddItemDataByName");
static_assert(offsetof(PhxCharacterInventoryComponent_AddItemDataByName, ItemName) == 0x000000, "Member 'PhxCharacterInventoryComponent_AddItemDataByName::ItemName' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_AddItemDataByName, Amount) == 0x000008, "Member 'PhxCharacterInventoryComponent_AddItemDataByName::Amount' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.AddNextItemPack
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterInventoryComponent_AddNextItemPack final
{
public:
	bool                                          bCanAddPack;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_AddNextItemPack) == 0x000001, "Wrong alignment on PhxCharacterInventoryComponent_AddNextItemPack");
static_assert(sizeof(PhxCharacterInventoryComponent_AddNextItemPack) == 0x000001, "Wrong size on PhxCharacterInventoryComponent_AddNextItemPack");
static_assert(offsetof(PhxCharacterInventoryComponent_AddNextItemPack, bCanAddPack) == 0x000000, "Member 'PhxCharacterInventoryComponent_AddNextItemPack::bCanAddPack' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.AddToViewedItems
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInventoryComponent_AddToViewedItems final
{
public:
	class FName                                   InName;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_AddToViewedItems) == 0x000004, "Wrong alignment on PhxCharacterInventoryComponent_AddToViewedItems");
static_assert(sizeof(PhxCharacterInventoryComponent_AddToViewedItems) == 0x000008, "Wrong size on PhxCharacterInventoryComponent_AddToViewedItems");
static_assert(offsetof(PhxCharacterInventoryComponent_AddToViewedItems, InName) == 0x000000, "Member 'PhxCharacterInventoryComponent_AddToViewedItems::InName' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.AddUploadedSchematics
// 0x0100 (0x0100 - 0x0000)
struct PhxCharacterInventoryComponent_AddUploadedSchematics final
{
public:
	struct FItemData                              Schematic;                                         // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_AddUploadedSchematics) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_AddUploadedSchematics");
static_assert(sizeof(PhxCharacterInventoryComponent_AddUploadedSchematics) == 0x000100, "Wrong size on PhxCharacterInventoryComponent_AddUploadedSchematics");
static_assert(offsetof(PhxCharacterInventoryComponent_AddUploadedSchematics, Schematic) == 0x000000, "Member 'PhxCharacterInventoryComponent_AddUploadedSchematics::Schematic' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.ApplyCraftingRecipe
// 0x0108 (0x0108 - 0x0000)
struct PhxCharacterInventoryComponent_ApplyCraftingRecipe final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	const class UPhxCraftingRecipe*               CraftingRecipe;                                    // 0x0100(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_ApplyCraftingRecipe) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_ApplyCraftingRecipe");
static_assert(sizeof(PhxCharacterInventoryComponent_ApplyCraftingRecipe) == 0x000108, "Wrong size on PhxCharacterInventoryComponent_ApplyCraftingRecipe");
static_assert(offsetof(PhxCharacterInventoryComponent_ApplyCraftingRecipe, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_ApplyCraftingRecipe::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_ApplyCraftingRecipe, CraftingRecipe) == 0x000100, "Member 'PhxCharacterInventoryComponent_ApplyCraftingRecipe::CraftingRecipe' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.CreateBioInInventory
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacterInventoryComponent_CreateBioInInventory final
{
public:
	TSubclassOf<class APhxBio>                    BioClass;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowNotification;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class APhxBio*                                ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_CreateBioInInventory) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_CreateBioInInventory");
static_assert(sizeof(PhxCharacterInventoryComponent_CreateBioInInventory) == 0x000018, "Wrong size on PhxCharacterInventoryComponent_CreateBioInInventory");
static_assert(offsetof(PhxCharacterInventoryComponent_CreateBioInInventory, BioClass) == 0x000000, "Member 'PhxCharacterInventoryComponent_CreateBioInInventory::BioClass' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CreateBioInInventory, bShowNotification) == 0x000008, "Member 'PhxCharacterInventoryComponent_CreateBioInInventory::bShowNotification' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CreateBioInInventory, ReturnValue) == 0x000010, "Member 'PhxCharacterInventoryComponent_CreateBioInInventory::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.CreateInInventory
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacterInventoryComponent_CreateInInventory final
{
public:
	TSubclassOf<class AEquippable>                EquippableClass;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumOfStacks;                                       // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowNotification;                                 // 0x000C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUnequipOnSpawn;                                   // 0x000D(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_E[0x2];                                        // 0x000E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	class AEquippable*                            ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_CreateInInventory) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_CreateInInventory");
static_assert(sizeof(PhxCharacterInventoryComponent_CreateInInventory) == 0x000018, "Wrong size on PhxCharacterInventoryComponent_CreateInInventory");
static_assert(offsetof(PhxCharacterInventoryComponent_CreateInInventory, EquippableClass) == 0x000000, "Member 'PhxCharacterInventoryComponent_CreateInInventory::EquippableClass' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CreateInInventory, NumOfStacks) == 0x000008, "Member 'PhxCharacterInventoryComponent_CreateInInventory::NumOfStacks' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CreateInInventory, bShowNotification) == 0x00000C, "Member 'PhxCharacterInventoryComponent_CreateInInventory::bShowNotification' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CreateInInventory, bUnequipOnSpawn) == 0x00000D, "Member 'PhxCharacterInventoryComponent_CreateInInventory::bUnequipOnSpawn' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CreateInInventory, ReturnValue) == 0x000010, "Member 'PhxCharacterInventoryComponent_CreateInInventory::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.DestroyEquipment
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_DestroyEquipment final
{
public:
	class AEquippable*                            ToDestroy;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         DestroyAt;                                         // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_DestroyEquipment) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_DestroyEquipment");
static_assert(sizeof(PhxCharacterInventoryComponent_DestroyEquipment) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_DestroyEquipment");
static_assert(offsetof(PhxCharacterInventoryComponent_DestroyEquipment, ToDestroy) == 0x000000, "Member 'PhxCharacterInventoryComponent_DestroyEquipment::ToDestroy' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_DestroyEquipment, DestroyAt) == 0x000008, "Member 'PhxCharacterInventoryComponent_DestroyEquipment::DestroyAt' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.DropEquipment
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_DropEquipment final
{
public:
	class AEquippable*                            ToDrop;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_DropEquipment) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_DropEquipment");
static_assert(sizeof(PhxCharacterInventoryComponent_DropEquipment) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_DropEquipment");
static_assert(offsetof(PhxCharacterInventoryComponent_DropEquipment, ToDrop) == 0x000000, "Member 'PhxCharacterInventoryComponent_DropEquipment::ToDrop' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_DropEquipment, ReturnValue) == 0x000008, "Member 'PhxCharacterInventoryComponent_DropEquipment::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.DropItem
// 0x0100 (0x0100 - 0x0000)
struct PhxCharacterInventoryComponent_DropItem final
{
public:
	struct FItemData                              ItemToDrop;                                        // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_DropItem) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_DropItem");
static_assert(sizeof(PhxCharacterInventoryComponent_DropItem) == 0x000100, "Wrong size on PhxCharacterInventoryComponent_DropItem");
static_assert(offsetof(PhxCharacterInventoryComponent_DropItem, ItemToDrop) == 0x000000, "Member 'PhxCharacterInventoryComponent_DropItem::ItemToDrop' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.FindUnlockingSchematic
// 0x0208 (0x0208 - 0x0000)
struct PhxCharacterInventoryComponent_FindUnlockingSchematic final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FItemData                              OutSchematic;                                      // 0x0100(0x0100)(Parm, OutParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0200(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_201[0x7];                                      // 0x0201(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_FindUnlockingSchematic) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_FindUnlockingSchematic");
static_assert(sizeof(PhxCharacterInventoryComponent_FindUnlockingSchematic) == 0x000208, "Wrong size on PhxCharacterInventoryComponent_FindUnlockingSchematic");
static_assert(offsetof(PhxCharacterInventoryComponent_FindUnlockingSchematic, InItem) == 0x000000, "Member 'PhxCharacterInventoryComponent_FindUnlockingSchematic::InItem' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_FindUnlockingSchematic, OutSchematic) == 0x000100, "Member 'PhxCharacterInventoryComponent_FindUnlockingSchematic::OutSchematic' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_FindUnlockingSchematic, ReturnValue) == 0x000200, "Member 'PhxCharacterInventoryComponent_FindUnlockingSchematic::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetAllItemData
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetAllItemData final
{
public:
	TArray<struct FItemData>                      ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetAllItemData) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetAllItemData");
static_assert(sizeof(PhxCharacterInventoryComponent_GetAllItemData) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetAllItemData");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAllItemData, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetAllItemData::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetDirtyFlag
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterInventoryComponent_GetDirtyFlag final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetDirtyFlag) == 0x000001, "Wrong alignment on PhxCharacterInventoryComponent_GetDirtyFlag");
static_assert(sizeof(PhxCharacterInventoryComponent_GetDirtyFlag) == 0x000001, "Wrong size on PhxCharacterInventoryComponent_GetDirtyFlag");
static_assert(offsetof(PhxCharacterInventoryComponent_GetDirtyFlag, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetDirtyFlag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetNextUsableConsumable
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInventoryComponent_GetNextUsableConsumable final
{
public:
	class AConsumable*                            ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetNextUsableConsumable) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetNextUsableConsumable");
static_assert(sizeof(PhxCharacterInventoryComponent_GetNextUsableConsumable) == 0x000008, "Wrong size on PhxCharacterInventoryComponent_GetNextUsableConsumable");
static_assert(offsetof(PhxCharacterInventoryComponent_GetNextUsableConsumable, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetNextUsableConsumable::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetNextUsableWeapon
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetNextUsableWeapon final
{
public:
	EAutoEquipCategory                            Type;                                              // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class AEquippable*                            ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetNextUsableWeapon) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetNextUsableWeapon");
static_assert(sizeof(PhxCharacterInventoryComponent_GetNextUsableWeapon) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetNextUsableWeapon");
static_assert(offsetof(PhxCharacterInventoryComponent_GetNextUsableWeapon, Type) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetNextUsableWeapon::Type' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetNextUsableWeapon, ReturnValue) == 0x000008, "Member 'PhxCharacterInventoryComponent_GetNextUsableWeapon::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.RemoveItem
// 0x000C (0x000C - 0x0000)
struct PhxCharacterInventoryComponent_RemoveItem final
{
public:
	class FName                                   ItemName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Amount;                                            // 0x0008(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_RemoveItem) == 0x000004, "Wrong alignment on PhxCharacterInventoryComponent_RemoveItem");
static_assert(sizeof(PhxCharacterInventoryComponent_RemoveItem) == 0x00000C, "Wrong size on PhxCharacterInventoryComponent_RemoveItem");
static_assert(offsetof(PhxCharacterInventoryComponent_RemoveItem, ItemName) == 0x000000, "Member 'PhxCharacterInventoryComponent_RemoveItem::ItemName' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_RemoveItem, Amount) == 0x000008, "Member 'PhxCharacterInventoryComponent_RemoveItem::Amount' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.RemoveItemData
// 0x0108 (0x0108 - 0x0000)
struct PhxCharacterInventoryComponent_RemoveItemData final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	int32                                         Amount;                                            // 0x0100(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_104[0x4];                                      // 0x0104(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_RemoveItemData) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_RemoveItemData");
static_assert(sizeof(PhxCharacterInventoryComponent_RemoveItemData) == 0x000108, "Wrong size on PhxCharacterInventoryComponent_RemoveItemData");
static_assert(offsetof(PhxCharacterInventoryComponent_RemoveItemData, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_RemoveItemData::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_RemoveItemData, Amount) == 0x000100, "Member 'PhxCharacterInventoryComponent_RemoveItemData::Amount' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.RemoveItemInSlot
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInventoryComponent_RemoveItemInSlot final
{
public:
	int32                                         SlotIndex;                                         // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Amount;                                            // 0x0004(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_RemoveItemInSlot) == 0x000004, "Wrong alignment on PhxCharacterInventoryComponent_RemoveItemInSlot");
static_assert(sizeof(PhxCharacterInventoryComponent_RemoveItemInSlot) == 0x000008, "Wrong size on PhxCharacterInventoryComponent_RemoveItemInSlot");
static_assert(offsetof(PhxCharacterInventoryComponent_RemoveItemInSlot, SlotIndex) == 0x000000, "Member 'PhxCharacterInventoryComponent_RemoveItemInSlot::SlotIndex' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_RemoveItemInSlot, Amount) == 0x000004, "Member 'PhxCharacterInventoryComponent_RemoveItemInSlot::Amount' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.SetDirtyFlag
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterInventoryComponent_SetDirtyFlag final
{
public:
	bool                                          bIsDirty;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_SetDirtyFlag) == 0x000001, "Wrong alignment on PhxCharacterInventoryComponent_SetDirtyFlag");
static_assert(sizeof(PhxCharacterInventoryComponent_SetDirtyFlag) == 0x000001, "Wrong size on PhxCharacterInventoryComponent_SetDirtyFlag");
static_assert(offsetof(PhxCharacterInventoryComponent_SetDirtyFlag, bIsDirty) == 0x000000, "Member 'PhxCharacterInventoryComponent_SetDirtyFlag::bIsDirty' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.SetUploadedSchematics
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_SetUploadedSchematics final
{
public:
	TArray<struct FItemData>                      Schematics;                                        // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_SetUploadedSchematics) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_SetUploadedSchematics");
static_assert(sizeof(PhxCharacterInventoryComponent_SetUploadedSchematics) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_SetUploadedSchematics");
static_assert(offsetof(PhxCharacterInventoryComponent_SetUploadedSchematics, Schematics) == 0x000000, "Member 'PhxCharacterInventoryComponent_SetUploadedSchematics::Schematics' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.SetViewedItems
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_SetViewedItems final
{
public:
	TArray<class FName>                           Items;                                             // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_SetViewedItems) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_SetViewedItems");
static_assert(sizeof(PhxCharacterInventoryComponent_SetViewedItems) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_SetViewedItems");
static_assert(offsetof(PhxCharacterInventoryComponent_SetViewedItems, Items) == 0x000000, "Member 'PhxCharacterInventoryComponent_SetViewedItems::Items' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.SetViewedSchematics
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_SetViewedSchematics final
{
public:
	TArray<struct FItemData>                      Schematics;                                        // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_SetViewedSchematics) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_SetViewedSchematics");
static_assert(sizeof(PhxCharacterInventoryComponent_SetViewedSchematics) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_SetViewedSchematics");
static_assert(offsetof(PhxCharacterInventoryComponent_SetViewedSchematics, Schematics) == 0x000000, "Member 'PhxCharacterInventoryComponent_SetViewedSchematics::Schematics' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.SpawnItemInWorld
// 0x0110 (0x0110 - 0x0000)
struct PhxCharacterInventoryComponent_SpawnItemInWorld final
{
public:
	struct FItemData                              ItemToSpawn;                                       // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FVector                                SpawnLocation;                                     // 0x0100(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_10C[0x4];                                      // 0x010C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_SpawnItemInWorld) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_SpawnItemInWorld");
static_assert(sizeof(PhxCharacterInventoryComponent_SpawnItemInWorld) == 0x000110, "Wrong size on PhxCharacterInventoryComponent_SpawnItemInWorld");
static_assert(offsetof(PhxCharacterInventoryComponent_SpawnItemInWorld, ItemToSpawn) == 0x000000, "Member 'PhxCharacterInventoryComponent_SpawnItemInWorld::ItemToSpawn' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_SpawnItemInWorld, SpawnLocation) == 0x000100, "Member 'PhxCharacterInventoryComponent_SpawnItemInWorld::SpawnLocation' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.StageEquip
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInventoryComponent_StageEquip final
{
public:
	class AEquippable*                            ToEquip;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_StageEquip) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_StageEquip");
static_assert(sizeof(PhxCharacterInventoryComponent_StageEquip) == 0x000008, "Wrong size on PhxCharacterInventoryComponent_StageEquip");
static_assert(offsetof(PhxCharacterInventoryComponent_StageEquip, ToEquip) == 0x000000, "Member 'PhxCharacterInventoryComponent_StageEquip::ToEquip' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.SwapRangedWeapon
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInventoryComponent_SwapRangedWeapon final
{
public:
	class APhxRangedWeapon*                       SwapTo;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_SwapRangedWeapon) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_SwapRangedWeapon");
static_assert(sizeof(PhxCharacterInventoryComponent_SwapRangedWeapon) == 0x000008, "Wrong size on PhxCharacterInventoryComponent_SwapRangedWeapon");
static_assert(offsetof(PhxCharacterInventoryComponent_SwapRangedWeapon, SwapTo) == 0x000000, "Member 'PhxCharacterInventoryComponent_SwapRangedWeapon::SwapTo' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.UpdateLastEquipmentCategories
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInventoryComponent_UpdateLastEquipmentCategories final
{
public:
	class AEquippable*                            Equip;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_UpdateLastEquipmentCategories) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_UpdateLastEquipmentCategories");
static_assert(sizeof(PhxCharacterInventoryComponent_UpdateLastEquipmentCategories) == 0x000008, "Wrong size on PhxCharacterInventoryComponent_UpdateLastEquipmentCategories");
static_assert(offsetof(PhxCharacterInventoryComponent_UpdateLastEquipmentCategories, Equip) == 0x000000, "Member 'PhxCharacterInventoryComponent_UpdateLastEquipmentCategories::Equip' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.AutoEquipOnPickup
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterInventoryComponent_AutoEquipOnPickup final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_AutoEquipOnPickup) == 0x000001, "Wrong alignment on PhxCharacterInventoryComponent_AutoEquipOnPickup");
static_assert(sizeof(PhxCharacterInventoryComponent_AutoEquipOnPickup) == 0x000001, "Wrong size on PhxCharacterInventoryComponent_AutoEquipOnPickup");
static_assert(offsetof(PhxCharacterInventoryComponent_AutoEquipOnPickup, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_AutoEquipOnPickup::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.CanAddItem
// 0x0108 (0x0108 - 0x0000)
struct PhxCharacterInventoryComponent_CanAddItem final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	int32                                         NumberOfStacks;                                    // 0x0100(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0104(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_105[0x3];                                      // 0x0105(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_CanAddItem) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_CanAddItem");
static_assert(sizeof(PhxCharacterInventoryComponent_CanAddItem) == 0x000108, "Wrong size on PhxCharacterInventoryComponent_CanAddItem");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAddItem, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_CanAddItem::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAddItem, NumberOfStacks) == 0x000100, "Member 'PhxCharacterInventoryComponent_CanAddItem::NumberOfStacks' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAddItem, ReturnValue) == 0x000104, "Member 'PhxCharacterInventoryComponent_CanAddItem::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.CanAffordAndAddItem
// 0x0110 (0x0110 - 0x0000)
struct PhxCharacterInventoryComponent_CanAffordAndAddItem final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	float                                         Discount;                                          // 0x0100(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumberOfStacks;                                    // 0x0104(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0108(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_109[0x7];                                      // 0x0109(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_CanAffordAndAddItem) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_CanAffordAndAddItem");
static_assert(sizeof(PhxCharacterInventoryComponent_CanAffordAndAddItem) == 0x000110, "Wrong size on PhxCharacterInventoryComponent_CanAffordAndAddItem");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordAndAddItem, InItem) == 0x000000, "Member 'PhxCharacterInventoryComponent_CanAffordAndAddItem::InItem' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordAndAddItem, Discount) == 0x000100, "Member 'PhxCharacterInventoryComponent_CanAffordAndAddItem::Discount' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordAndAddItem, NumberOfStacks) == 0x000104, "Member 'PhxCharacterInventoryComponent_CanAffordAndAddItem::NumberOfStacks' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordAndAddItem, ReturnValue) == 0x000108, "Member 'PhxCharacterInventoryComponent_CanAffordAndAddItem::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.CanAffordItem
// 0x0110 (0x0110 - 0x0000)
struct PhxCharacterInventoryComponent_CanAffordItem final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	float                                         Discount;                                          // 0x0100(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumberOfStacks;                                    // 0x0104(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0108(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_109[0x7];                                      // 0x0109(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_CanAffordItem) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_CanAffordItem");
static_assert(sizeof(PhxCharacterInventoryComponent_CanAffordItem) == 0x000110, "Wrong size on PhxCharacterInventoryComponent_CanAffordItem");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordItem, InItem) == 0x000000, "Member 'PhxCharacterInventoryComponent_CanAffordItem::InItem' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordItem, Discount) == 0x000100, "Member 'PhxCharacterInventoryComponent_CanAffordItem::Discount' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordItem, NumberOfStacks) == 0x000104, "Member 'PhxCharacterInventoryComponent_CanAffordItem::NumberOfStacks' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordItem, ReturnValue) == 0x000108, "Member 'PhxCharacterInventoryComponent_CanAffordItem::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.CanAffordRecipe
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_CanAffordRecipe final
{
public:
	const class UPhxCraftingRecipe*               Recipe;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Discount;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x000C(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_CanAffordRecipe) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_CanAffordRecipe");
static_assert(sizeof(PhxCharacterInventoryComponent_CanAffordRecipe) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_CanAffordRecipe");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordRecipe, Recipe) == 0x000000, "Member 'PhxCharacterInventoryComponent_CanAffordRecipe::Recipe' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordRecipe, Discount) == 0x000008, "Member 'PhxCharacterInventoryComponent_CanAffordRecipe::Discount' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanAffordRecipe, ReturnValue) == 0x00000C, "Member 'PhxCharacterInventoryComponent_CanAffordRecipe::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.CanRecipeBeCrafted
// 0x0110 (0x0110 - 0x0000)
struct PhxCharacterInventoryComponent_CanRecipeBeCrafted final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	const class UPhxCraftingRecipe*               Recipe;                                            // 0x0100(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Discount;                                          // 0x0108(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x010C(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_10D[0x3];                                      // 0x010D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_CanRecipeBeCrafted) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_CanRecipeBeCrafted");
static_assert(sizeof(PhxCharacterInventoryComponent_CanRecipeBeCrafted) == 0x000110, "Wrong size on PhxCharacterInventoryComponent_CanRecipeBeCrafted");
static_assert(offsetof(PhxCharacterInventoryComponent_CanRecipeBeCrafted, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_CanRecipeBeCrafted::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanRecipeBeCrafted, Recipe) == 0x000100, "Member 'PhxCharacterInventoryComponent_CanRecipeBeCrafted::Recipe' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanRecipeBeCrafted, Discount) == 0x000108, "Member 'PhxCharacterInventoryComponent_CanRecipeBeCrafted::Discount' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_CanRecipeBeCrafted, ReturnValue) == 0x00010C, "Member 'PhxCharacterInventoryComponent_CanRecipeBeCrafted::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.FindItemDataByClass
// 0x0110 (0x0110 - 0x0000)
struct PhxCharacterInventoryComponent_FindItemDataByClass final
{
public:
	const class UClass*                           PickupClass;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FItemData                              OutItem;                                           // 0x0008(0x0100)(Parm, OutParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0108(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_109[0x7];                                      // 0x0109(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_FindItemDataByClass) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_FindItemDataByClass");
static_assert(sizeof(PhxCharacterInventoryComponent_FindItemDataByClass) == 0x000110, "Wrong size on PhxCharacterInventoryComponent_FindItemDataByClass");
static_assert(offsetof(PhxCharacterInventoryComponent_FindItemDataByClass, PickupClass) == 0x000000, "Member 'PhxCharacterInventoryComponent_FindItemDataByClass::PickupClass' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_FindItemDataByClass, OutItem) == 0x000008, "Member 'PhxCharacterInventoryComponent_FindItemDataByClass::OutItem' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_FindItemDataByClass, ReturnValue) == 0x000108, "Member 'PhxCharacterInventoryComponent_FindItemDataByClass::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.FindItemDataBySoftClass
// 0x0130 (0x0130 - 0x0000)
struct PhxCharacterInventoryComponent_FindItemDataBySoftClass final
{
public:
	TSoftClassPtr<class UClass>                   InClass;                                           // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FItemData                              OutItem;                                           // 0x0028(0x0100)(Parm, OutParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0128(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_129[0x7];                                      // 0x0129(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_FindItemDataBySoftClass) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_FindItemDataBySoftClass");
static_assert(sizeof(PhxCharacterInventoryComponent_FindItemDataBySoftClass) == 0x000130, "Wrong size on PhxCharacterInventoryComponent_FindItemDataBySoftClass");
static_assert(offsetof(PhxCharacterInventoryComponent_FindItemDataBySoftClass, InClass) == 0x000000, "Member 'PhxCharacterInventoryComponent_FindItemDataBySoftClass::InClass' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_FindItemDataBySoftClass, OutItem) == 0x000028, "Member 'PhxCharacterInventoryComponent_FindItemDataBySoftClass::OutItem' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_FindItemDataBySoftClass, ReturnValue) == 0x000128, "Member 'PhxCharacterInventoryComponent_FindItemDataBySoftClass::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.FindItemWithSlotIndex
// 0x0110 (0x0110 - 0x0000)
struct PhxCharacterInventoryComponent_FindItemWithSlotIndex final
{
public:
	int32                                         SlotIndex;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FItemData                              OutItem;                                           // 0x0008(0x0100)(Parm, OutParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0108(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_109[0x7];                                      // 0x0109(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_FindItemWithSlotIndex) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_FindItemWithSlotIndex");
static_assert(sizeof(PhxCharacterInventoryComponent_FindItemWithSlotIndex) == 0x000110, "Wrong size on PhxCharacterInventoryComponent_FindItemWithSlotIndex");
static_assert(offsetof(PhxCharacterInventoryComponent_FindItemWithSlotIndex, SlotIndex) == 0x000000, "Member 'PhxCharacterInventoryComponent_FindItemWithSlotIndex::SlotIndex' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_FindItemWithSlotIndex, OutItem) == 0x000008, "Member 'PhxCharacterInventoryComponent_FindItemWithSlotIndex::OutItem' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_FindItemWithSlotIndex, ReturnValue) == 0x000108, "Member 'PhxCharacterInventoryComponent_FindItemWithSlotIndex::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.FindRangedWeaponBySoftClass
// 0x0030 (0x0030 - 0x0000)
struct PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass final
{
public:
	TSoftClassPtr<class UClass>                   InClass;                                           // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxRangedWeapon*                       ReturnValue;                                       // 0x0028(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass");
static_assert(sizeof(PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass) == 0x000030, "Wrong size on PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass");
static_assert(offsetof(PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass, InClass) == 0x000000, "Member 'PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass::InClass' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass, ReturnValue) == 0x000028, "Member 'PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetAllBios
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetAllBios final
{
public:
	TArray<class APhxBio*>                        ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetAllBios) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetAllBios");
static_assert(sizeof(PhxCharacterInventoryComponent_GetAllBios) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetAllBios");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAllBios, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetAllBios::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetAllEquipment
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetAllEquipment final
{
public:
	TArray<class AEquippable*>                    ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetAllEquipment) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetAllEquipment");
static_assert(sizeof(PhxCharacterInventoryComponent_GetAllEquipment) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetAllEquipment");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAllEquipment, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetAllEquipment::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetAllUnlockedRecipes
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetAllUnlockedRecipes final
{
public:
	TArray<class UPhxCraftingRecipe*>             OutRecipes;                                        // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetAllUnlockedRecipes) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetAllUnlockedRecipes");
static_assert(sizeof(PhxCharacterInventoryComponent_GetAllUnlockedRecipes) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetAllUnlockedRecipes");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAllUnlockedRecipes, OutRecipes) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetAllUnlockedRecipes::OutRecipes' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetAllUnlockedRecipesForItem
// 0x0118 (0x0118 - 0x0000)
struct PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	TArray<class UPhxCraftingRecipe*>             OutRecipes;                                        // 0x0100(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0110(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_111[0x7];                                      // 0x0111(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem");
static_assert(sizeof(PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem) == 0x000118, "Wrong size on PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem, OutRecipes) == 0x000100, "Member 'PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem::OutRecipes' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem, ReturnValue) == 0x000110, "Member 'PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetAvailableQuantity
// 0x0108 (0x0108 - 0x0000)
struct PhxCharacterInventoryComponent_GetAvailableQuantity final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	int32                                         NumberOfStacks;                                    // 0x0100(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0104(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetAvailableQuantity) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetAvailableQuantity");
static_assert(sizeof(PhxCharacterInventoryComponent_GetAvailableQuantity) == 0x000108, "Wrong size on PhxCharacterInventoryComponent_GetAvailableQuantity");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAvailableQuantity, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetAvailableQuantity::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAvailableQuantity, NumberOfStacks) == 0x000100, "Member 'PhxCharacterInventoryComponent_GetAvailableQuantity::NumberOfStacks' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetAvailableQuantity, ReturnValue) == 0x000104, "Member 'PhxCharacterInventoryComponent_GetAvailableQuantity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetConsumableByCategory
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetConsumableByCategory final
{
public:
	EItemDataCategory                             ConsumableCategory;                                // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class AConsumable*                            ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetConsumableByCategory) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetConsumableByCategory");
static_assert(sizeof(PhxCharacterInventoryComponent_GetConsumableByCategory) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetConsumableByCategory");
static_assert(offsetof(PhxCharacterInventoryComponent_GetConsumableByCategory, ConsumableCategory) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetConsumableByCategory::ConsumableCategory' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetConsumableByCategory, ReturnValue) == 0x000008, "Member 'PhxCharacterInventoryComponent_GetConsumableByCategory::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetEquipmentWithGameplayTag
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag final
{
public:
	struct FGameplayTag                           Tag;                                               // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AEquippable*                            ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag");
static_assert(sizeof(PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag");
static_assert(offsetof(PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag, Tag) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag::Tag' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag, ReturnValue) == 0x000008, "Member 'PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetEquipped
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInventoryComponent_GetEquipped final
{
public:
	class AEquippable*                            ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetEquipped) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetEquipped");
static_assert(sizeof(PhxCharacterInventoryComponent_GetEquipped) == 0x000008, "Wrong size on PhxCharacterInventoryComponent_GetEquipped");
static_assert(offsetof(PhxCharacterInventoryComponent_GetEquipped, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetEquipped::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetEquippedAux
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInventoryComponent_GetEquippedAux final
{
public:
	class AEquippable*                            ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetEquippedAux) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetEquippedAux");
static_assert(sizeof(PhxCharacterInventoryComponent_GetEquippedAux) == 0x000008, "Wrong size on PhxCharacterInventoryComponent_GetEquippedAux");
static_assert(offsetof(PhxCharacterInventoryComponent_GetEquippedAux, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetEquippedAux::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetItemDataQuantity
// 0x0108 (0x0108 - 0x0000)
struct PhxCharacterInventoryComponent_GetItemDataQuantity final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0100(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_104[0x4];                                      // 0x0104(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_GetItemDataQuantity) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetItemDataQuantity");
static_assert(sizeof(PhxCharacterInventoryComponent_GetItemDataQuantity) == 0x000108, "Wrong size on PhxCharacterInventoryComponent_GetItemDataQuantity");
static_assert(offsetof(PhxCharacterInventoryComponent_GetItemDataQuantity, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetItemDataQuantity::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetItemDataQuantity, ReturnValue) == 0x000100, "Member 'PhxCharacterInventoryComponent_GetItemDataQuantity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetItemQuantity
// 0x000C (0x000C - 0x0000)
struct PhxCharacterInventoryComponent_GetItemQuantity final
{
public:
	class FName                                   ItemName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetItemQuantity) == 0x000004, "Wrong alignment on PhxCharacterInventoryComponent_GetItemQuantity");
static_assert(sizeof(PhxCharacterInventoryComponent_GetItemQuantity) == 0x00000C, "Wrong size on PhxCharacterInventoryComponent_GetItemQuantity");
static_assert(offsetof(PhxCharacterInventoryComponent_GetItemQuantity, ItemName) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetItemQuantity::ItemName' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetItemQuantity, ReturnValue) == 0x000008, "Member 'PhxCharacterInventoryComponent_GetItemQuantity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetLastEquipped
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetLastEquipped final
{
public:
	EItemDataSubCategory                          Category;                                          // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class AEquippable*                            ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetLastEquipped) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetLastEquipped");
static_assert(sizeof(PhxCharacterInventoryComponent_GetLastEquipped) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetLastEquipped");
static_assert(offsetof(PhxCharacterInventoryComponent_GetLastEquipped, Category) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetLastEquipped::Category' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetLastEquipped, ReturnValue) == 0x000008, "Member 'PhxCharacterInventoryComponent_GetLastEquipped::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetLastEquippedRanged
// 0x0008 (0x0008 - 0x0000)
struct PhxCharacterInventoryComponent_GetLastEquippedRanged final
{
public:
	class APhxRangedWeapon*                       ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetLastEquippedRanged) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetLastEquippedRanged");
static_assert(sizeof(PhxCharacterInventoryComponent_GetLastEquippedRanged) == 0x000008, "Wrong size on PhxCharacterInventoryComponent_GetLastEquippedRanged");
static_assert(offsetof(PhxCharacterInventoryComponent_GetLastEquippedRanged, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetLastEquippedRanged::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetPlayerCredits
// 0x0004 (0x0004 - 0x0000)
struct PhxCharacterInventoryComponent_GetPlayerCredits final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetPlayerCredits) == 0x000004, "Wrong alignment on PhxCharacterInventoryComponent_GetPlayerCredits");
static_assert(sizeof(PhxCharacterInventoryComponent_GetPlayerCredits) == 0x000004, "Wrong size on PhxCharacterInventoryComponent_GetPlayerCredits");
static_assert(offsetof(PhxCharacterInventoryComponent_GetPlayerCredits, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetPlayerCredits::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetRangedWeapons
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacterInventoryComponent_GetRangedWeapons final
{
public:
	EItemDataSubCategory                          Category;                                          // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class APhxRangedWeapon*>               OutRangedWeapons;                                  // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetRangedWeapons) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetRangedWeapons");
static_assert(sizeof(PhxCharacterInventoryComponent_GetRangedWeapons) == 0x000018, "Wrong size on PhxCharacterInventoryComponent_GetRangedWeapons");
static_assert(offsetof(PhxCharacterInventoryComponent_GetRangedWeapons, Category) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetRangedWeapons::Category' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetRangedWeapons, OutRangedWeapons) == 0x000008, "Member 'PhxCharacterInventoryComponent_GetRangedWeapons::OutRangedWeapons' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetUnusedSchematics
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacterInventoryComponent_GetUnusedSchematics final
{
public:
	EItemDataSubCategory                          Category;                                          // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FItemData>                      UnusedSchematics;                                  // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetUnusedSchematics) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetUnusedSchematics");
static_assert(sizeof(PhxCharacterInventoryComponent_GetUnusedSchematics) == 0x000018, "Wrong size on PhxCharacterInventoryComponent_GetUnusedSchematics");
static_assert(offsetof(PhxCharacterInventoryComponent_GetUnusedSchematics, Category) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetUnusedSchematics::Category' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetUnusedSchematics, UnusedSchematics) == 0x000008, "Member 'PhxCharacterInventoryComponent_GetUnusedSchematics::UnusedSchematics' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetUploadedSchematics
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetUploadedSchematics final
{
public:
	TArray<struct FItemData>                      ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetUploadedSchematics) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetUploadedSchematics");
static_assert(sizeof(PhxCharacterInventoryComponent_GetUploadedSchematics) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetUploadedSchematics");
static_assert(offsetof(PhxCharacterInventoryComponent_GetUploadedSchematics, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetUploadedSchematics::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetViewedItems
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetViewedItems final
{
public:
	TArray<class FName>                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetViewedItems) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetViewedItems");
static_assert(sizeof(PhxCharacterInventoryComponent_GetViewedItems) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetViewedItems");
static_assert(offsetof(PhxCharacterInventoryComponent_GetViewedItems, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetViewedItems::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetViewedSchematics
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetViewedSchematics final
{
public:
	TArray<struct FItemData>                      ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetViewedSchematics) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetViewedSchematics");
static_assert(sizeof(PhxCharacterInventoryComponent_GetViewedSchematics) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetViewedSchematics");
static_assert(offsetof(PhxCharacterInventoryComponent_GetViewedSchematics, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetViewedSchematics::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetWeaponSchematics
// 0x0010 (0x0010 - 0x0000)
struct PhxCharacterInventoryComponent_GetWeaponSchematics final
{
public:
	TArray<struct FItemData>                      OutSchematics;                                     // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_GetWeaponSchematics) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetWeaponSchematics");
static_assert(sizeof(PhxCharacterInventoryComponent_GetWeaponSchematics) == 0x000010, "Wrong size on PhxCharacterInventoryComponent_GetWeaponSchematics");
static_assert(offsetof(PhxCharacterInventoryComponent_GetWeaponSchematics, OutSchematics) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetWeaponSchematics::OutSchematics' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.GetWeaponSchematicsExceptCategory
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory final
{
public:
	TArray<struct FItemData>                      OutSchematics;                                     // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
	EItemDataCategory                             Category;                                          // 0x0010(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory");
static_assert(sizeof(PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory) == 0x000018, "Wrong size on PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory");
static_assert(offsetof(PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory, OutSchematics) == 0x000000, "Member 'PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory::OutSchematics' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory, Category) == 0x000010, "Member 'PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory::Category' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.HasBio
// 0x000C (0x000C - 0x0000)
struct PhxCharacterInventoryComponent_HasBio final
{
public:
	class FName                                   BioNameID;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_HasBio) == 0x000004, "Wrong alignment on PhxCharacterInventoryComponent_HasBio");
static_assert(sizeof(PhxCharacterInventoryComponent_HasBio) == 0x00000C, "Wrong size on PhxCharacterInventoryComponent_HasBio");
static_assert(offsetof(PhxCharacterInventoryComponent_HasBio, BioNameID) == 0x000000, "Member 'PhxCharacterInventoryComponent_HasBio::BioNameID' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_HasBio, ReturnValue) == 0x000008, "Member 'PhxCharacterInventoryComponent_HasBio::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.HasItem
// 0x0108 (0x0108 - 0x0000)
struct PhxCharacterInventoryComponent_HasItem final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0100(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_101[0x7];                                      // 0x0101(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_HasItem) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_HasItem");
static_assert(sizeof(PhxCharacterInventoryComponent_HasItem) == 0x000108, "Wrong size on PhxCharacterInventoryComponent_HasItem");
static_assert(offsetof(PhxCharacterInventoryComponent_HasItem, InItem) == 0x000000, "Member 'PhxCharacterInventoryComponent_HasItem::InItem' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_HasItem, ReturnValue) == 0x000100, "Member 'PhxCharacterInventoryComponent_HasItem::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.HasRangedWeapon
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterInventoryComponent_HasRangedWeapon final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_HasRangedWeapon) == 0x000001, "Wrong alignment on PhxCharacterInventoryComponent_HasRangedWeapon");
static_assert(sizeof(PhxCharacterInventoryComponent_HasRangedWeapon) == 0x000001, "Wrong size on PhxCharacterInventoryComponent_HasRangedWeapon");
static_assert(offsetof(PhxCharacterInventoryComponent_HasRangedWeapon, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_HasRangedWeapon::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.HasSchematicsToUpload
// 0x0001 (0x0001 - 0x0000)
struct PhxCharacterInventoryComponent_HasSchematicsToUpload final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCharacterInventoryComponent_HasSchematicsToUpload) == 0x000001, "Wrong alignment on PhxCharacterInventoryComponent_HasSchematicsToUpload");
static_assert(sizeof(PhxCharacterInventoryComponent_HasSchematicsToUpload) == 0x000001, "Wrong size on PhxCharacterInventoryComponent_HasSchematicsToUpload");
static_assert(offsetof(PhxCharacterInventoryComponent_HasSchematicsToUpload, ReturnValue) == 0x000000, "Member 'PhxCharacterInventoryComponent_HasSchematicsToUpload::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.HasWeapon
// 0x0018 (0x0018 - 0x0000)
struct PhxCharacterInventoryComponent_HasWeapon final
{
public:
	class FString                                 WeaponSpawnId;                                     // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_HasWeapon) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_HasWeapon");
static_assert(sizeof(PhxCharacterInventoryComponent_HasWeapon) == 0x000018, "Wrong size on PhxCharacterInventoryComponent_HasWeapon");
static_assert(offsetof(PhxCharacterInventoryComponent_HasWeapon, WeaponSpawnId) == 0x000000, "Member 'PhxCharacterInventoryComponent_HasWeapon::WeaponSpawnId' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_HasWeapon, ReturnValue) == 0x000010, "Member 'PhxCharacterInventoryComponent_HasWeapon::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.IsBioDecrypted
// 0x000C (0x000C - 0x0000)
struct PhxCharacterInventoryComponent_IsBioDecrypted final
{
public:
	class FName                                   BioNameID;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_IsBioDecrypted) == 0x000004, "Wrong alignment on PhxCharacterInventoryComponent_IsBioDecrypted");
static_assert(sizeof(PhxCharacterInventoryComponent_IsBioDecrypted) == 0x00000C, "Wrong size on PhxCharacterInventoryComponent_IsBioDecrypted");
static_assert(offsetof(PhxCharacterInventoryComponent_IsBioDecrypted, BioNameID) == 0x000000, "Member 'PhxCharacterInventoryComponent_IsBioDecrypted::BioNameID' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_IsBioDecrypted, ReturnValue) == 0x000008, "Member 'PhxCharacterInventoryComponent_IsBioDecrypted::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.IsRecipeUnlocked
// 0x0110 (0x0110 - 0x0000)
struct PhxCharacterInventoryComponent_IsRecipeUnlocked final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	const class UPhxCraftingRecipe*               Recipe;                                            // 0x0100(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0108(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_109[0x7];                                      // 0x0109(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_IsRecipeUnlocked) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_IsRecipeUnlocked");
static_assert(sizeof(PhxCharacterInventoryComponent_IsRecipeUnlocked) == 0x000110, "Wrong size on PhxCharacterInventoryComponent_IsRecipeUnlocked");
static_assert(offsetof(PhxCharacterInventoryComponent_IsRecipeUnlocked, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_IsRecipeUnlocked::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_IsRecipeUnlocked, Recipe) == 0x000100, "Member 'PhxCharacterInventoryComponent_IsRecipeUnlocked::Recipe' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_IsRecipeUnlocked, ReturnValue) == 0x000108, "Member 'PhxCharacterInventoryComponent_IsRecipeUnlocked::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.ItemHasRecipeApplied
// 0x0110 (0x0110 - 0x0000)
struct PhxCharacterInventoryComponent_ItemHasRecipeApplied final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	const class UPhxCraftingRecipe*               UpgradeRecipe;                                     // 0x0100(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0108(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_109[0x7];                                      // 0x0109(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_ItemHasRecipeApplied) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_ItemHasRecipeApplied");
static_assert(sizeof(PhxCharacterInventoryComponent_ItemHasRecipeApplied) == 0x000110, "Wrong size on PhxCharacterInventoryComponent_ItemHasRecipeApplied");
static_assert(offsetof(PhxCharacterInventoryComponent_ItemHasRecipeApplied, ItemData) == 0x000000, "Member 'PhxCharacterInventoryComponent_ItemHasRecipeApplied::ItemData' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_ItemHasRecipeApplied, UpgradeRecipe) == 0x000100, "Member 'PhxCharacterInventoryComponent_ItemHasRecipeApplied::UpgradeRecipe' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_ItemHasRecipeApplied, ReturnValue) == 0x000108, "Member 'PhxCharacterInventoryComponent_ItemHasRecipeApplied::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCharacterInventoryComponent.ItemRequiresSlotIndex
// 0x0108 (0x0108 - 0x0000)
struct PhxCharacterInventoryComponent_ItemRequiresSlotIndex final
{
public:
	struct FItemData                              Item;                                              // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0100(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_101[0x7];                                      // 0x0101(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCharacterInventoryComponent_ItemRequiresSlotIndex) == 0x000008, "Wrong alignment on PhxCharacterInventoryComponent_ItemRequiresSlotIndex");
static_assert(sizeof(PhxCharacterInventoryComponent_ItemRequiresSlotIndex) == 0x000108, "Wrong size on PhxCharacterInventoryComponent_ItemRequiresSlotIndex");
static_assert(offsetof(PhxCharacterInventoryComponent_ItemRequiresSlotIndex, Item) == 0x000000, "Member 'PhxCharacterInventoryComponent_ItemRequiresSlotIndex::Item' has a wrong offset!");
static_assert(offsetof(PhxCharacterInventoryComponent_ItemRequiresSlotIndex, ReturnValue) == 0x000100, "Member 'PhxCharacterInventoryComponent_ItemRequiresSlotIndex::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCheatManager.GetAllDLCAnimationsUnlocked
// 0x0001 (0x0001 - 0x0000)
struct PhxCheatManager_GetAllDLCAnimationsUnlocked final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_GetAllDLCAnimationsUnlocked) == 0x000001, "Wrong alignment on PhxCheatManager_GetAllDLCAnimationsUnlocked");
static_assert(sizeof(PhxCheatManager_GetAllDLCAnimationsUnlocked) == 0x000001, "Wrong size on PhxCheatManager_GetAllDLCAnimationsUnlocked");
static_assert(offsetof(PhxCheatManager_GetAllDLCAnimationsUnlocked, ReturnValue) == 0x000000, "Member 'PhxCheatManager_GetAllDLCAnimationsUnlocked::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCheatManager.GetDebugHealthBarsEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxCheatManager_GetDebugHealthBarsEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_GetDebugHealthBarsEnabled) == 0x000001, "Wrong alignment on PhxCheatManager_GetDebugHealthBarsEnabled");
static_assert(sizeof(PhxCheatManager_GetDebugHealthBarsEnabled) == 0x000001, "Wrong size on PhxCheatManager_GetDebugHealthBarsEnabled");
static_assert(offsetof(PhxCheatManager_GetDebugHealthBarsEnabled, ReturnValue) == 0x000000, "Member 'PhxCheatManager_GetDebugHealthBarsEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCheatManager.GetDebugStoppingPowerBarsEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxCheatManager_GetDebugStoppingPowerBarsEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_GetDebugStoppingPowerBarsEnabled) == 0x000001, "Wrong alignment on PhxCheatManager_GetDebugStoppingPowerBarsEnabled");
static_assert(sizeof(PhxCheatManager_GetDebugStoppingPowerBarsEnabled) == 0x000001, "Wrong size on PhxCheatManager_GetDebugStoppingPowerBarsEnabled");
static_assert(offsetof(PhxCheatManager_GetDebugStoppingPowerBarsEnabled, ReturnValue) == 0x000000, "Member 'PhxCheatManager_GetDebugStoppingPowerBarsEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCheatManager.GetRiotModeUIEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxCheatManager_GetRiotModeUIEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_GetRiotModeUIEnabled) == 0x000001, "Wrong alignment on PhxCheatManager_GetRiotModeUIEnabled");
static_assert(sizeof(PhxCheatManager_GetRiotModeUIEnabled) == 0x000001, "Wrong size on PhxCheatManager_GetRiotModeUIEnabled");
static_assert(offsetof(PhxCheatManager_GetRiotModeUIEnabled, ReturnValue) == 0x000000, "Member 'PhxCheatManager_GetRiotModeUIEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCheatManager.DebugSpawnEnemyAtLookAtPos
// 0x0020 (0x0020 - 0x0000)
struct PhxCheatManager_DebugSpawnEnemyAtLookAtPos final
{
public:
	struct FSoftObjectPath                        AICharacterDefinitionPath;                         // 0x0000(0x0018)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         CharacterVariation;                                // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCheatManager_DebugSpawnEnemyAtLookAtPos) == 0x000008, "Wrong alignment on PhxCheatManager_DebugSpawnEnemyAtLookAtPos");
static_assert(sizeof(PhxCheatManager_DebugSpawnEnemyAtLookAtPos) == 0x000020, "Wrong size on PhxCheatManager_DebugSpawnEnemyAtLookAtPos");
static_assert(offsetof(PhxCheatManager_DebugSpawnEnemyAtLookAtPos, AICharacterDefinitionPath) == 0x000000, "Member 'PhxCheatManager_DebugSpawnEnemyAtLookAtPos::AICharacterDefinitionPath' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_DebugSpawnEnemyAtLookAtPos, CharacterVariation) == 0x000018, "Member 'PhxCheatManager_DebugSpawnEnemyAtLookAtPos::CharacterVariation' has a wrong offset!");

// Function Phoenix.PhxCheatManager.HandleAISpawnedForPairedKill
// 0x0010 (0x0010 - 0x0000)
struct PhxCheatManager_HandleAISpawnedForPairedKill final
{
public:
	class APhxAICharacter*                        SpawnedAI;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAISpawnResultCode                         ResultCode;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SpawnUid;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_HandleAISpawnedForPairedKill) == 0x000008, "Wrong alignment on PhxCheatManager_HandleAISpawnedForPairedKill");
static_assert(sizeof(PhxCheatManager_HandleAISpawnedForPairedKill) == 0x000010, "Wrong size on PhxCheatManager_HandleAISpawnedForPairedKill");
static_assert(offsetof(PhxCheatManager_HandleAISpawnedForPairedKill, SpawnedAI) == 0x000000, "Member 'PhxCheatManager_HandleAISpawnedForPairedKill::SpawnedAI' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_HandleAISpawnedForPairedKill, ResultCode) == 0x000008, "Member 'PhxCheatManager_HandleAISpawnedForPairedKill::ResultCode' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_HandleAISpawnedForPairedKill, SpawnUid) == 0x00000C, "Member 'PhxCheatManager_HandleAISpawnedForPairedKill::SpawnUid' has a wrong offset!");

// Function Phoenix.PhxCheatManager.ModifyObjectProperty
// 0x0030 (0x0030 - 0x0000)
struct PhxCheatManager_ModifyObjectProperty final
{
public:
	class FString                                 ObjectName;                                        // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 PropertyName;                                      // 0x0010(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NewPropertyValue1;                                 // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NewPropertyValue2;                                 // 0x0024(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NewPropertyValue3;                                 // 0x0028(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCheatManager_ModifyObjectProperty) == 0x000008, "Wrong alignment on PhxCheatManager_ModifyObjectProperty");
static_assert(sizeof(PhxCheatManager_ModifyObjectProperty) == 0x000030, "Wrong size on PhxCheatManager_ModifyObjectProperty");
static_assert(offsetof(PhxCheatManager_ModifyObjectProperty, ObjectName) == 0x000000, "Member 'PhxCheatManager_ModifyObjectProperty::ObjectName' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_ModifyObjectProperty, PropertyName) == 0x000010, "Member 'PhxCheatManager_ModifyObjectProperty::PropertyName' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_ModifyObjectProperty, NewPropertyValue1) == 0x000020, "Member 'PhxCheatManager_ModifyObjectProperty::NewPropertyValue1' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_ModifyObjectProperty, NewPropertyValue2) == 0x000024, "Member 'PhxCheatManager_ModifyObjectProperty::NewPropertyValue2' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_ModifyObjectProperty, NewPropertyValue3) == 0x000028, "Member 'PhxCheatManager_ModifyObjectProperty::NewPropertyValue3' has a wrong offset!");

// Function Phoenix.PhxCheatManager.OnCheatScriptedEventCharacterFreed
// 0x0010 (0x0010 - 0x0000)
struct PhxCheatManager_OnCheatScriptedEventCharacterFreed final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BindingTag;                                        // 0x0008(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_OnCheatScriptedEventCharacterFreed) == 0x000008, "Wrong alignment on PhxCheatManager_OnCheatScriptedEventCharacterFreed");
static_assert(sizeof(PhxCheatManager_OnCheatScriptedEventCharacterFreed) == 0x000010, "Wrong size on PhxCheatManager_OnCheatScriptedEventCharacterFreed");
static_assert(offsetof(PhxCheatManager_OnCheatScriptedEventCharacterFreed, Character) == 0x000000, "Member 'PhxCheatManager_OnCheatScriptedEventCharacterFreed::Character' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_OnCheatScriptedEventCharacterFreed, BindingTag) == 0x000008, "Member 'PhxCheatManager_OnCheatScriptedEventCharacterFreed::BindingTag' has a wrong offset!");

// Function Phoenix.PhxCheatManager.PilotCamGo
// 0x0018 (0x0018 - 0x0000)
struct PhxCheatManager_PilotCamGo final
{
public:
	float                                         X;                                                 // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Y;                                                 // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Z;                                                 // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Pitch;                                             // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Yaw;                                               // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Roll;                                              // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_PilotCamGo) == 0x000004, "Wrong alignment on PhxCheatManager_PilotCamGo");
static_assert(sizeof(PhxCheatManager_PilotCamGo) == 0x000018, "Wrong size on PhxCheatManager_PilotCamGo");
static_assert(offsetof(PhxCheatManager_PilotCamGo, X) == 0x000000, "Member 'PhxCheatManager_PilotCamGo::X' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PilotCamGo, Y) == 0x000004, "Member 'PhxCheatManager_PilotCamGo::Y' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PilotCamGo, Z) == 0x000008, "Member 'PhxCheatManager_PilotCamGo::Z' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PilotCamGo, Pitch) == 0x00000C, "Member 'PhxCheatManager_PilotCamGo::Pitch' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PilotCamGo, Yaw) == 0x000010, "Member 'PhxCheatManager_PilotCamGo::Yaw' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PilotCamGo, Roll) == 0x000014, "Member 'PhxCheatManager_PilotCamGo::Roll' has a wrong offset!");

// Function Phoenix.PhxCheatManager.PS5HapticDisable
// 0x0004 (0x0004 - 0x0000)
struct PhxCheatManager_PS5HapticDisable final
{
public:
	int32                                         TriggerSide;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_PS5HapticDisable) == 0x000004, "Wrong alignment on PhxCheatManager_PS5HapticDisable");
static_assert(sizeof(PhxCheatManager_PS5HapticDisable) == 0x000004, "Wrong size on PhxCheatManager_PS5HapticDisable");
static_assert(offsetof(PhxCheatManager_PS5HapticDisable, TriggerSide) == 0x000000, "Member 'PhxCheatManager_PS5HapticDisable::TriggerSide' has a wrong offset!");

// Function Phoenix.PhxCheatManager.PS5HapticFeedbackMode
// 0x000C (0x000C - 0x0000)
struct PhxCheatManager_PS5HapticFeedbackMode final
{
public:
	int32                                         TriggerSide;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Position;                                          // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Strength;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_PS5HapticFeedbackMode) == 0x000004, "Wrong alignment on PhxCheatManager_PS5HapticFeedbackMode");
static_assert(sizeof(PhxCheatManager_PS5HapticFeedbackMode) == 0x00000C, "Wrong size on PhxCheatManager_PS5HapticFeedbackMode");
static_assert(offsetof(PhxCheatManager_PS5HapticFeedbackMode, TriggerSide) == 0x000000, "Member 'PhxCheatManager_PS5HapticFeedbackMode::TriggerSide' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PS5HapticFeedbackMode, Position) == 0x000004, "Member 'PhxCheatManager_PS5HapticFeedbackMode::Position' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PS5HapticFeedbackMode, Strength) == 0x000008, "Member 'PhxCheatManager_PS5HapticFeedbackMode::Strength' has a wrong offset!");

// Function Phoenix.PhxCheatManager.PS5HapticVibrationMode
// 0x0010 (0x0010 - 0x0000)
struct PhxCheatManager_PS5HapticVibrationMode final
{
public:
	int32                                         TriggerSide;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Position;                                          // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Frequency;                                         // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Amplitude;                                         // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_PS5HapticVibrationMode) == 0x000004, "Wrong alignment on PhxCheatManager_PS5HapticVibrationMode");
static_assert(sizeof(PhxCheatManager_PS5HapticVibrationMode) == 0x000010, "Wrong size on PhxCheatManager_PS5HapticVibrationMode");
static_assert(offsetof(PhxCheatManager_PS5HapticVibrationMode, TriggerSide) == 0x000000, "Member 'PhxCheatManager_PS5HapticVibrationMode::TriggerSide' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PS5HapticVibrationMode, Position) == 0x000004, "Member 'PhxCheatManager_PS5HapticVibrationMode::Position' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PS5HapticVibrationMode, Frequency) == 0x000008, "Member 'PhxCheatManager_PS5HapticVibrationMode::Frequency' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PS5HapticVibrationMode, Amplitude) == 0x00000C, "Member 'PhxCheatManager_PS5HapticVibrationMode::Amplitude' has a wrong offset!");

// Function Phoenix.PhxCheatManager.PS5HapticWeaponMode
// 0x0010 (0x0010 - 0x0000)
struct PhxCheatManager_PS5HapticWeaponMode final
{
public:
	int32                                         TriggerSide;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         StartPos;                                          // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         EndPos;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Strength;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_PS5HapticWeaponMode) == 0x000004, "Wrong alignment on PhxCheatManager_PS5HapticWeaponMode");
static_assert(sizeof(PhxCheatManager_PS5HapticWeaponMode) == 0x000010, "Wrong size on PhxCheatManager_PS5HapticWeaponMode");
static_assert(offsetof(PhxCheatManager_PS5HapticWeaponMode, TriggerSide) == 0x000000, "Member 'PhxCheatManager_PS5HapticWeaponMode::TriggerSide' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PS5HapticWeaponMode, StartPos) == 0x000004, "Member 'PhxCheatManager_PS5HapticWeaponMode::StartPos' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PS5HapticWeaponMode, EndPos) == 0x000008, "Member 'PhxCheatManager_PS5HapticWeaponMode::EndPos' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_PS5HapticWeaponMode, Strength) == 0x00000C, "Member 'PhxCheatManager_PS5HapticWeaponMode::Strength' has a wrong offset!");

// Function Phoenix.PhxCheatManager.SetOnlineStatus
// 0x0001 (0x0001 - 0x0000)
struct PhxCheatManager_SetOnlineStatus final
{
public:
	bool                                          bOnline;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_SetOnlineStatus) == 0x000001, "Wrong alignment on PhxCheatManager_SetOnlineStatus");
static_assert(sizeof(PhxCheatManager_SetOnlineStatus) == 0x000001, "Wrong size on PhxCheatManager_SetOnlineStatus");
static_assert(offsetof(PhxCheatManager_SetOnlineStatus, bOnline) == 0x000000, "Member 'PhxCheatManager_SetOnlineStatus::bOnline' has a wrong offset!");

// Function Phoenix.PhxCheatManager.StreamGlobalLevelIn
// 0x0010 (0x0010 - 0x0000)
struct PhxCheatManager_StreamGlobalLevelIn final
{
public:
	class FName                                   Map;                                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Section;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_StreamGlobalLevelIn) == 0x000004, "Wrong alignment on PhxCheatManager_StreamGlobalLevelIn");
static_assert(sizeof(PhxCheatManager_StreamGlobalLevelIn) == 0x000010, "Wrong size on PhxCheatManager_StreamGlobalLevelIn");
static_assert(offsetof(PhxCheatManager_StreamGlobalLevelIn, Map) == 0x000000, "Member 'PhxCheatManager_StreamGlobalLevelIn::Map' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_StreamGlobalLevelIn, Section) == 0x000008, "Member 'PhxCheatManager_StreamGlobalLevelIn::Section' has a wrong offset!");

// Function Phoenix.PhxCheatManager.StreamGlobalLevelOut
// 0x0010 (0x0010 - 0x0000)
struct PhxCheatManager_StreamGlobalLevelOut final
{
public:
	class FName                                   Map;                                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Section;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_StreamGlobalLevelOut) == 0x000004, "Wrong alignment on PhxCheatManager_StreamGlobalLevelOut");
static_assert(sizeof(PhxCheatManager_StreamGlobalLevelOut) == 0x000010, "Wrong size on PhxCheatManager_StreamGlobalLevelOut");
static_assert(offsetof(PhxCheatManager_StreamGlobalLevelOut, Map) == 0x000000, "Member 'PhxCheatManager_StreamGlobalLevelOut::Map' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_StreamGlobalLevelOut, Section) == 0x000008, "Member 'PhxCheatManager_StreamGlobalLevelOut::Section' has a wrong offset!");

// Function Phoenix.PhxCheatManager.StreamLevelSectionIn
// 0x0018 (0x0018 - 0x0000)
struct PhxCheatManager_StreamLevelSectionIn final
{
public:
	class FName                                   Map;                                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Section;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Subsection;                                        // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_StreamLevelSectionIn) == 0x000004, "Wrong alignment on PhxCheatManager_StreamLevelSectionIn");
static_assert(sizeof(PhxCheatManager_StreamLevelSectionIn) == 0x000018, "Wrong size on PhxCheatManager_StreamLevelSectionIn");
static_assert(offsetof(PhxCheatManager_StreamLevelSectionIn, Map) == 0x000000, "Member 'PhxCheatManager_StreamLevelSectionIn::Map' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_StreamLevelSectionIn, Section) == 0x000008, "Member 'PhxCheatManager_StreamLevelSectionIn::Section' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_StreamLevelSectionIn, Subsection) == 0x000010, "Member 'PhxCheatManager_StreamLevelSectionIn::Subsection' has a wrong offset!");

// Function Phoenix.PhxCheatManager.StreamLevelSectionOut
// 0x0018 (0x0018 - 0x0000)
struct PhxCheatManager_StreamLevelSectionOut final
{
public:
	class FName                                   Map;                                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Section;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Subsection;                                        // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_StreamLevelSectionOut) == 0x000004, "Wrong alignment on PhxCheatManager_StreamLevelSectionOut");
static_assert(sizeof(PhxCheatManager_StreamLevelSectionOut) == 0x000018, "Wrong size on PhxCheatManager_StreamLevelSectionOut");
static_assert(offsetof(PhxCheatManager_StreamLevelSectionOut, Map) == 0x000000, "Member 'PhxCheatManager_StreamLevelSectionOut::Map' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_StreamLevelSectionOut, Section) == 0x000008, "Member 'PhxCheatManager_StreamLevelSectionOut::Section' has a wrong offset!");
static_assert(offsetof(PhxCheatManager_StreamLevelSectionOut, Subsection) == 0x000010, "Member 'PhxCheatManager_StreamLevelSectionOut::Subsection' has a wrong offset!");

// Function Phoenix.PhxCheatManager.ToggleLightShadows
// 0x0010 (0x0010 - 0x0000)
struct PhxCheatManager_ToggleLightShadows final
{
public:
	class FString                                 LightName;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_ToggleLightShadows) == 0x000008, "Wrong alignment on PhxCheatManager_ToggleLightShadows");
static_assert(sizeof(PhxCheatManager_ToggleLightShadows) == 0x000010, "Wrong size on PhxCheatManager_ToggleLightShadows");
static_assert(offsetof(PhxCheatManager_ToggleLightShadows, LightName) == 0x000000, "Member 'PhxCheatManager_ToggleLightShadows::LightName' has a wrong offset!");

// Function Phoenix.PhxCheatManager.UnloadStreamingLevel
// 0x0008 (0x0008 - 0x0000)
struct PhxCheatManager_UnloadStreamingLevel final
{
public:
	class FName                                   StreamingLevelName;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_UnloadStreamingLevel) == 0x000004, "Wrong alignment on PhxCheatManager_UnloadStreamingLevel");
static_assert(sizeof(PhxCheatManager_UnloadStreamingLevel) == 0x000008, "Wrong size on PhxCheatManager_UnloadStreamingLevel");
static_assert(offsetof(PhxCheatManager_UnloadStreamingLevel, StreamingLevelName) == 0x000000, "Member 'PhxCheatManager_UnloadStreamingLevel::StreamingLevelName' has a wrong offset!");

// Function Phoenix.PhxCheatManager.IsInputDebuggerActive
// 0x0001 (0x0001 - 0x0000)
struct PhxCheatManager_IsInputDebuggerActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_IsInputDebuggerActive) == 0x000001, "Wrong alignment on PhxCheatManager_IsInputDebuggerActive");
static_assert(sizeof(PhxCheatManager_IsInputDebuggerActive) == 0x000001, "Wrong size on PhxCheatManager_IsInputDebuggerActive");
static_assert(offsetof(PhxCheatManager_IsInputDebuggerActive, ReturnValue) == 0x000000, "Member 'PhxCheatManager_IsInputDebuggerActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCheatManager.IsMarketingCameraHudActive
// 0x0001 (0x0001 - 0x0000)
struct PhxCheatManager_IsMarketingCameraHudActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_IsMarketingCameraHudActive) == 0x000001, "Wrong alignment on PhxCheatManager_IsMarketingCameraHudActive");
static_assert(sizeof(PhxCheatManager_IsMarketingCameraHudActive) == 0x000001, "Wrong size on PhxCheatManager_IsMarketingCameraHudActive");
static_assert(offsetof(PhxCheatManager_IsMarketingCameraHudActive, ReturnValue) == 0x000000, "Member 'PhxCheatManager_IsMarketingCameraHudActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCheatManager.IsSpeedThroughToggleEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxCheatManager_IsSpeedThroughToggleEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCheatManager_IsSpeedThroughToggleEnabled) == 0x000001, "Wrong alignment on PhxCheatManager_IsSpeedThroughToggleEnabled");
static_assert(sizeof(PhxCheatManager_IsSpeedThroughToggleEnabled) == 0x000001, "Wrong size on PhxCheatManager_IsSpeedThroughToggleEnabled");
static_assert(offsetof(PhxCheatManager_IsSpeedThroughToggleEnabled, ReturnValue) == 0x000000, "Member 'PhxCheatManager_IsSpeedThroughToggleEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSQuickSwapHandler.QuickSwapDirectionInput
// 0x0001 (0x0001 - 0x0000)
struct SDSQuickSwapHandler_QuickSwapDirectionInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSQuickSwapHandler_QuickSwapDirectionInput) == 0x000001, "Wrong alignment on SDSQuickSwapHandler_QuickSwapDirectionInput");
static_assert(sizeof(SDSQuickSwapHandler_QuickSwapDirectionInput) == 0x000001, "Wrong size on SDSQuickSwapHandler_QuickSwapDirectionInput");
static_assert(offsetof(SDSQuickSwapHandler_QuickSwapDirectionInput, Direction) == 0x000000, "Member 'SDSQuickSwapHandler_QuickSwapDirectionInput::Direction' has a wrong offset!");

// Function Phoenix.SDSPromptWidget.SetMessage
// 0x0018 (0x0018 - 0x0000)
struct SDSPromptWidget_SetMessage final
{
public:
	class FText                                   InMessage;                                         // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSPromptWidget_SetMessage) == 0x000008, "Wrong alignment on SDSPromptWidget_SetMessage");
static_assert(sizeof(SDSPromptWidget_SetMessage) == 0x000018, "Wrong size on SDSPromptWidget_SetMessage");
static_assert(offsetof(SDSPromptWidget_SetMessage, InMessage) == 0x000000, "Member 'SDSPromptWidget_SetMessage::InMessage' has a wrong offset!");

// Function Phoenix.SheenComponent.CreateSheenMesh_Skeletal
// 0x0010 (0x0010 - 0x0000)
struct SheenComponent_CreateSheenMesh_Skeletal final
{
public:
	class USkeletalMeshComponent*                 SkeletalMeshComp;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ID;                                                // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(SheenComponent_CreateSheenMesh_Skeletal) == 0x000008, "Wrong alignment on SheenComponent_CreateSheenMesh_Skeletal");
static_assert(sizeof(SheenComponent_CreateSheenMesh_Skeletal) == 0x000010, "Wrong size on SheenComponent_CreateSheenMesh_Skeletal");
static_assert(offsetof(SheenComponent_CreateSheenMesh_Skeletal, SkeletalMeshComp) == 0x000000, "Member 'SheenComponent_CreateSheenMesh_Skeletal::SkeletalMeshComp' has a wrong offset!");
static_assert(offsetof(SheenComponent_CreateSheenMesh_Skeletal, ID) == 0x000008, "Member 'SheenComponent_CreateSheenMesh_Skeletal::ID' has a wrong offset!");

// Function Phoenix.SheenComponent.CreateSheenMesh_Static
// 0x0010 (0x0010 - 0x0000)
struct SheenComponent_CreateSheenMesh_Static final
{
public:
	class UStaticMeshComponent*                   StaticMeshComp;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ID;                                                // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(SheenComponent_CreateSheenMesh_Static) == 0x000008, "Wrong alignment on SheenComponent_CreateSheenMesh_Static");
static_assert(sizeof(SheenComponent_CreateSheenMesh_Static) == 0x000010, "Wrong size on SheenComponent_CreateSheenMesh_Static");
static_assert(offsetof(SheenComponent_CreateSheenMesh_Static, StaticMeshComp) == 0x000000, "Member 'SheenComponent_CreateSheenMesh_Static::StaticMeshComp' has a wrong offset!");
static_assert(offsetof(SheenComponent_CreateSheenMesh_Static, ID) == 0x000008, "Member 'SheenComponent_CreateSheenMesh_Static::ID' has a wrong offset!");

// Function Phoenix.SheenComponent.SetSheenIntensity
// 0x0004 (0x0004 - 0x0000)
struct SheenComponent_SetSheenIntensity final
{
public:
	float                                         Value;                                             // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SheenComponent_SetSheenIntensity) == 0x000004, "Wrong alignment on SheenComponent_SetSheenIntensity");
static_assert(sizeof(SheenComponent_SetSheenIntensity) == 0x000004, "Wrong size on SheenComponent_SetSheenIntensity");
static_assert(offsetof(SheenComponent_SetSheenIntensity, Value) == 0x000000, "Member 'SheenComponent_SetSheenIntensity::Value' has a wrong offset!");

// Function Phoenix.SessionListWidget.BeginServerSearch
// 0x0018 (0x0018 - 0x0000)
struct SessionListWidget_BeginServerSearch final
{
public:
	bool                                          bLANMatch;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsDedicatedServer;                                // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2[0x6];                                        // 0x0002(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 InMapFilterName;                                   // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SessionListWidget_BeginServerSearch) == 0x000008, "Wrong alignment on SessionListWidget_BeginServerSearch");
static_assert(sizeof(SessionListWidget_BeginServerSearch) == 0x000018, "Wrong size on SessionListWidget_BeginServerSearch");
static_assert(offsetof(SessionListWidget_BeginServerSearch, bLANMatch) == 0x000000, "Member 'SessionListWidget_BeginServerSearch::bLANMatch' has a wrong offset!");
static_assert(offsetof(SessionListWidget_BeginServerSearch, bIsDedicatedServer) == 0x000001, "Member 'SessionListWidget_BeginServerSearch::bIsDedicatedServer' has a wrong offset!");
static_assert(offsetof(SessionListWidget_BeginServerSearch, InMapFilterName) == 0x000008, "Member 'SessionListWidget_BeginServerSearch::InMapFilterName' has a wrong offset!");

// Function Phoenix.PhxCinematicsComponent.OnAnimMontageStartedForLevelSequenceActor0
// 0x0008 (0x0008 - 0x0000)
struct PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor0 final
{
public:
	class UAnimMontage*                           AnimMontage;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor0) == 0x000008, "Wrong alignment on PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor0");
static_assert(sizeof(PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor0) == 0x000008, "Wrong size on PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor0");
static_assert(offsetof(PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor0, AnimMontage) == 0x000000, "Member 'PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor0::AnimMontage' has a wrong offset!");

// Function Phoenix.PhxCinematicsComponent.OnAnimMontageStartedForLevelSequenceActor1
// 0x0008 (0x0008 - 0x0000)
struct PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor1 final
{
public:
	class UAnimMontage*                           AnimMontage;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor1) == 0x000008, "Wrong alignment on PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor1");
static_assert(sizeof(PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor1) == 0x000008, "Wrong size on PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor1");
static_assert(offsetof(PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor1, AnimMontage) == 0x000000, "Member 'PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor1::AnimMontage' has a wrong offset!");

// Function Phoenix.PhxCinematicsComponent.OnCharacterDeath
// 0x0020 (0x0020 - 0x0000)
struct PhxCinematicsComponent_OnCharacterDeath final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCinematicsComponent_OnCharacterDeath) == 0x000008, "Wrong alignment on PhxCinematicsComponent_OnCharacterDeath");
static_assert(sizeof(PhxCinematicsComponent_OnCharacterDeath) == 0x000020, "Wrong size on PhxCinematicsComponent_OnCharacterDeath");
static_assert(offsetof(PhxCinematicsComponent_OnCharacterDeath, DeadCharacter) == 0x000000, "Member 'PhxCinematicsComponent_OnCharacterDeath::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxCinematicsComponent_OnCharacterDeath, KillerActor) == 0x000008, "Member 'PhxCinematicsComponent_OnCharacterDeath::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxCinematicsComponent_OnCharacterDeath, KillerController) == 0x000010, "Member 'PhxCinematicsComponent_OnCharacterDeath::KillerController' has a wrong offset!");
static_assert(offsetof(PhxCinematicsComponent_OnCharacterDeath, KillingBlowHealthDelta) == 0x000018, "Member 'PhxCinematicsComponent_OnCharacterDeath::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxCinematicsComponent.OnParticipantSpawned
// 0x0010 (0x0010 - 0x0000)
struct PhxCinematicsComponent_OnParticipantSpawned final
{
public:
	class APhxAICharacter*                        SpawnedAI;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAISpawnResultCode                         ResultCode;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SpawnUid;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCinematicsComponent_OnParticipantSpawned) == 0x000008, "Wrong alignment on PhxCinematicsComponent_OnParticipantSpawned");
static_assert(sizeof(PhxCinematicsComponent_OnParticipantSpawned) == 0x000010, "Wrong size on PhxCinematicsComponent_OnParticipantSpawned");
static_assert(offsetof(PhxCinematicsComponent_OnParticipantSpawned, SpawnedAI) == 0x000000, "Member 'PhxCinematicsComponent_OnParticipantSpawned::SpawnedAI' has a wrong offset!");
static_assert(offsetof(PhxCinematicsComponent_OnParticipantSpawned, ResultCode) == 0x000008, "Member 'PhxCinematicsComponent_OnParticipantSpawned::ResultCode' has a wrong offset!");
static_assert(offsetof(PhxCinematicsComponent_OnParticipantSpawned, SpawnUid) == 0x00000C, "Member 'PhxCinematicsComponent_OnParticipantSpawned::SpawnUid' has a wrong offset!");

// Function Phoenix.PhxCinematicsComponent.SetRootOverrideLevelSequenceIndex
// 0x0004 (0x0004 - 0x0000)
struct PhxCinematicsComponent_SetRootOverrideLevelSequenceIndex final
{
public:
	int32                                         OverrideIndex;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCinematicsComponent_SetRootOverrideLevelSequenceIndex) == 0x000004, "Wrong alignment on PhxCinematicsComponent_SetRootOverrideLevelSequenceIndex");
static_assert(sizeof(PhxCinematicsComponent_SetRootOverrideLevelSequenceIndex) == 0x000004, "Wrong size on PhxCinematicsComponent_SetRootOverrideLevelSequenceIndex");
static_assert(offsetof(PhxCinematicsComponent_SetRootOverrideLevelSequenceIndex, OverrideIndex) == 0x000000, "Member 'PhxCinematicsComponent_SetRootOverrideLevelSequenceIndex::OverrideIndex' has a wrong offset!");

// Function Phoenix.PhxCinematicsComponent.GetCurrentLevelSequenceActor
// 0x0008 (0x0008 - 0x0000)
struct PhxCinematicsComponent_GetCurrentLevelSequenceActor final
{
public:
	class ALevelSequenceActor*                    ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCinematicsComponent_GetCurrentLevelSequenceActor) == 0x000008, "Wrong alignment on PhxCinematicsComponent_GetCurrentLevelSequenceActor");
static_assert(sizeof(PhxCinematicsComponent_GetCurrentLevelSequenceActor) == 0x000008, "Wrong size on PhxCinematicsComponent_GetCurrentLevelSequenceActor");
static_assert(offsetof(PhxCinematicsComponent_GetCurrentLevelSequenceActor, ReturnValue) == 0x000000, "Member 'PhxCinematicsComponent_GetCurrentLevelSequenceActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCinematicsComponent.GetFinalBlendTime
// 0x0004 (0x0004 - 0x0000)
struct PhxCinematicsComponent_GetFinalBlendTime final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCinematicsComponent_GetFinalBlendTime) == 0x000004, "Wrong alignment on PhxCinematicsComponent_GetFinalBlendTime");
static_assert(sizeof(PhxCinematicsComponent_GetFinalBlendTime) == 0x000004, "Wrong size on PhxCinematicsComponent_GetFinalBlendTime");
static_assert(offsetof(PhxCinematicsComponent_GetFinalBlendTime, ReturnValue) == 0x000000, "Member 'PhxCinematicsComponent_GetFinalBlendTime::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2PrintState.CharacterNotify
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2PrintState_CharacterNotify final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2PrintState_CharacterNotify) == 0x000008, "Wrong alignment on PrinterV2PrintState_CharacterNotify");
static_assert(sizeof(PrinterV2PrintState_CharacterNotify) == 0x000008, "Wrong size on PrinterV2PrintState_CharacterNotify");
static_assert(offsetof(PrinterV2PrintState_CharacterNotify, Notify) == 0x000000, "Member 'PrinterV2PrintState_CharacterNotify::Notify' has a wrong offset!");

// Function Phoenix.PrinterV2PrintState.PrinterNotify
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2PrintState_PrinterNotify final
{
public:
	const class UPhxPrinterAnimNotify*            Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2PrintState_PrinterNotify) == 0x000008, "Wrong alignment on PrinterV2PrintState_PrinterNotify");
static_assert(sizeof(PrinterV2PrintState_PrinterNotify) == 0x000008, "Wrong size on PrinterV2PrintState_PrinterNotify");
static_assert(offsetof(PrinterV2PrintState_PrinterNotify, Notify) == 0x000000, "Member 'PrinterV2PrintState_PrinterNotify::Notify' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_EquipWeapon.OnNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayAbility_EquipWeapon_OnNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   AnimNotify;                                        // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_EquipWeapon_OnNotifyReceived) == 0x000008, "Wrong alignment on PhxGameplayAbility_EquipWeapon_OnNotifyReceived");
static_assert(sizeof(PhxGameplayAbility_EquipWeapon_OnNotifyReceived) == 0x000008, "Wrong size on PhxGameplayAbility_EquipWeapon_OnNotifyReceived");
static_assert(offsetof(PhxGameplayAbility_EquipWeapon_OnNotifyReceived, AnimNotify) == 0x000000, "Member 'PhxGameplayAbility_EquipWeapon_OnNotifyReceived::AnimNotify' has a wrong offset!");

// Function Phoenix.PrinterV2FSM.InteractExecuted
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2FSM_InteractExecuted final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2FSM_InteractExecuted) == 0x000008, "Wrong alignment on PrinterV2FSM_InteractExecuted");
static_assert(sizeof(PrinterV2FSM_InteractExecuted) == 0x000008, "Wrong size on PrinterV2FSM_InteractExecuted");
static_assert(offsetof(PrinterV2FSM_InteractExecuted, InteractedBy) == 0x000000, "Member 'PrinterV2FSM_InteractExecuted::InteractedBy' has a wrong offset!");

// Function Phoenix.PrinterV2FSM.OnScriptedEventCharacterFreed
// 0x0010 (0x0010 - 0x0000)
struct PrinterV2FSM_OnScriptedEventCharacterFreed final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BindingTag;                                        // 0x0008(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2FSM_OnScriptedEventCharacterFreed) == 0x000008, "Wrong alignment on PrinterV2FSM_OnScriptedEventCharacterFreed");
static_assert(sizeof(PrinterV2FSM_OnScriptedEventCharacterFreed) == 0x000010, "Wrong size on PrinterV2FSM_OnScriptedEventCharacterFreed");
static_assert(offsetof(PrinterV2FSM_OnScriptedEventCharacterFreed, Character) == 0x000000, "Member 'PrinterV2FSM_OnScriptedEventCharacterFreed::Character' has a wrong offset!");
static_assert(offsetof(PrinterV2FSM_OnScriptedEventCharacterFreed, BindingTag) == 0x000008, "Member 'PrinterV2FSM_OnScriptedEventCharacterFreed::BindingTag' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_GRPEnemyLaunch.OnEnemyHit
// 0x00B0 (0x00B0 - 0x0000)
struct PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit) == 0x000008, "Wrong alignment on PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit");
static_assert(sizeof(PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit) == 0x0000B0, "Wrong size on PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit, HitComp) == 0x000000, "Member 'PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit::HitComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit, OtherActor) == 0x000008, "Member 'PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit, OtherComp) == 0x000010, "Member 'PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit, NormalImpulse) == 0x000018, "Member 'PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit, Hit) == 0x000024, "Member 'PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit::Hit' has a wrong offset!");

// Function Phoenix.PhxCombatSubsystem.RegisterPlayerDeathHideActor
// 0x0008 (0x0008 - 0x0000)
struct PhxCombatSubsystem_RegisterPlayerDeathHideActor final
{
public:
	class AActor*                                 HideActor;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCombatSubsystem_RegisterPlayerDeathHideActor) == 0x000008, "Wrong alignment on PhxCombatSubsystem_RegisterPlayerDeathHideActor");
static_assert(sizeof(PhxCombatSubsystem_RegisterPlayerDeathHideActor) == 0x000008, "Wrong size on PhxCombatSubsystem_RegisterPlayerDeathHideActor");
static_assert(offsetof(PhxCombatSubsystem_RegisterPlayerDeathHideActor, HideActor) == 0x000000, "Member 'PhxCombatSubsystem_RegisterPlayerDeathHideActor::HideActor' has a wrong offset!");

// Function Phoenix.PhxCombatSubsystem.UnregisterPlayerDeathHideActor
// 0x0008 (0x0008 - 0x0000)
struct PhxCombatSubsystem_UnregisterPlayerDeathHideActor final
{
public:
	class AActor*                                 HideActor;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCombatSubsystem_UnregisterPlayerDeathHideActor) == 0x000008, "Wrong alignment on PhxCombatSubsystem_UnregisterPlayerDeathHideActor");
static_assert(sizeof(PhxCombatSubsystem_UnregisterPlayerDeathHideActor) == 0x000008, "Wrong size on PhxCombatSubsystem_UnregisterPlayerDeathHideActor");
static_assert(offsetof(PhxCombatSubsystem_UnregisterPlayerDeathHideActor, HideActor) == 0x000000, "Member 'PhxCombatSubsystem_UnregisterPlayerDeathHideActor::HideActor' has a wrong offset!");

// Function Phoenix.PhxCustomizationManager.AreAllSkinsUnlockedViaCheat
// 0x0001 (0x0001 - 0x0000)
struct PhxCustomizationManager_AreAllSkinsUnlockedViaCheat final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCustomizationManager_AreAllSkinsUnlockedViaCheat) == 0x000001, "Wrong alignment on PhxCustomizationManager_AreAllSkinsUnlockedViaCheat");
static_assert(sizeof(PhxCustomizationManager_AreAllSkinsUnlockedViaCheat) == 0x000001, "Wrong size on PhxCustomizationManager_AreAllSkinsUnlockedViaCheat");
static_assert(offsetof(PhxCustomizationManager_AreAllSkinsUnlockedViaCheat, ReturnValue) == 0x000000, "Member 'PhxCustomizationManager_AreAllSkinsUnlockedViaCheat::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCustomizationManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxCustomizationManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxCustomizationManager*               ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCustomizationManager_Get) == 0x000008, "Wrong alignment on PhxCustomizationManager_Get");
static_assert(sizeof(PhxCustomizationManager_Get) == 0x000010, "Wrong size on PhxCustomizationManager_Get");
static_assert(offsetof(PhxCustomizationManager_Get, WorldContextObject) == 0x000000, "Member 'PhxCustomizationManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxCustomizationManager_Get, ReturnValue) == 0x000008, "Member 'PhxCustomizationManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCustomizationManager.GetSkinEntitlementId
// 0x0010 (0x0010 - 0x0000)
struct PhxCustomizationManager_GetSkinEntitlementId final
{
public:
	class UPhxCharacterSkin*                      Skin;                                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxEntitlement                               ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxCustomizationManager_GetSkinEntitlementId) == 0x000008, "Wrong alignment on PhxCustomizationManager_GetSkinEntitlementId");
static_assert(sizeof(PhxCustomizationManager_GetSkinEntitlementId) == 0x000010, "Wrong size on PhxCustomizationManager_GetSkinEntitlementId");
static_assert(offsetof(PhxCustomizationManager_GetSkinEntitlementId, Skin) == 0x000000, "Member 'PhxCustomizationManager_GetSkinEntitlementId::Skin' has a wrong offset!");
static_assert(offsetof(PhxCustomizationManager_GetSkinEntitlementId, ReturnValue) == 0x000008, "Member 'PhxCustomizationManager_GetSkinEntitlementId::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCustomizationManager.OnAccountChanged
// 0x0008 (0x0008 - 0x0000)
struct PhxCustomizationManager_OnAccountChanged final
{
public:
	class USDSOnlineAccount*                      NewAccount;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCustomizationManager_OnAccountChanged) == 0x000008, "Wrong alignment on PhxCustomizationManager_OnAccountChanged");
static_assert(sizeof(PhxCustomizationManager_OnAccountChanged) == 0x000008, "Wrong size on PhxCustomizationManager_OnAccountChanged");
static_assert(offsetof(PhxCustomizationManager_OnAccountChanged, NewAccount) == 0x000000, "Member 'PhxCustomizationManager_OnAccountChanged::NewAccount' has a wrong offset!");

// Function Phoenix.PhxCustomizationManager.OnSkinValidationResultReceived
// 0x0001 (0x0001 - 0x0000)
struct PhxCustomizationManager_OnSkinValidationResultReceived final
{
public:
	bool                                          bHasEntitlement;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCustomizationManager_OnSkinValidationResultReceived) == 0x000001, "Wrong alignment on PhxCustomizationManager_OnSkinValidationResultReceived");
static_assert(sizeof(PhxCustomizationManager_OnSkinValidationResultReceived) == 0x000001, "Wrong size on PhxCustomizationManager_OnSkinValidationResultReceived");
static_assert(offsetof(PhxCustomizationManager_OnSkinValidationResultReceived, bHasEntitlement) == 0x000000, "Member 'PhxCustomizationManager_OnSkinValidationResultReceived::bHasEntitlement' has a wrong offset!");

// Function Phoenix.PhxCustomizationManager.SetPlayerSkinIndex
// 0x0004 (0x0004 - 0x0000)
struct PhxCustomizationManager_SetPlayerSkinIndex final
{
public:
	int32                                         SkinIndex;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCustomizationManager_SetPlayerSkinIndex) == 0x000004, "Wrong alignment on PhxCustomizationManager_SetPlayerSkinIndex");
static_assert(sizeof(PhxCustomizationManager_SetPlayerSkinIndex) == 0x000004, "Wrong size on PhxCustomizationManager_SetPlayerSkinIndex");
static_assert(offsetof(PhxCustomizationManager_SetPlayerSkinIndex, SkinIndex) == 0x000000, "Member 'PhxCustomizationManager_SetPlayerSkinIndex::SkinIndex' has a wrong offset!");

// Function Phoenix.PhxCustomizationManager.GetActivePlayerSkin
// 0x0008 (0x0008 - 0x0000)
struct PhxCustomizationManager_GetActivePlayerSkin final
{
public:
	class UPhxCharacterSkin*                      ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCustomizationManager_GetActivePlayerSkin) == 0x000008, "Wrong alignment on PhxCustomizationManager_GetActivePlayerSkin");
static_assert(sizeof(PhxCustomizationManager_GetActivePlayerSkin) == 0x000008, "Wrong size on PhxCustomizationManager_GetActivePlayerSkin");
static_assert(offsetof(PhxCustomizationManager_GetActivePlayerSkin, ReturnValue) == 0x000000, "Member 'PhxCustomizationManager_GetActivePlayerSkin::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxCustomizationManager.GetCurrentPlayerSkinIndex
// 0x0004 (0x0004 - 0x0000)
struct PhxCustomizationManager_GetCurrentPlayerSkinIndex final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxCustomizationManager_GetCurrentPlayerSkinIndex) == 0x000004, "Wrong alignment on PhxCustomizationManager_GetCurrentPlayerSkinIndex");
static_assert(sizeof(PhxCustomizationManager_GetCurrentPlayerSkinIndex) == 0x000004, "Wrong size on PhxCustomizationManager_GetCurrentPlayerSkinIndex");
static_assert(offsetof(PhxCustomizationManager_GetCurrentPlayerSkinIndex, ReturnValue) == 0x000000, "Member 'PhxCustomizationManager_GetCurrentPlayerSkinIndex::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDebugCamera.DumpCameraInfo
// 0x0010 (0x0010 - 0x0000)
struct PhxDebugCamera_DumpCameraInfo final
{
public:
	class FString                                 Filename;                                          // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDebugCamera_DumpCameraInfo) == 0x000008, "Wrong alignment on PhxDebugCamera_DumpCameraInfo");
static_assert(sizeof(PhxDebugCamera_DumpCameraInfo) == 0x000010, "Wrong size on PhxDebugCamera_DumpCameraInfo");
static_assert(offsetof(PhxDebugCamera_DumpCameraInfo, Filename) == 0x000000, "Member 'PhxDebugCamera_DumpCameraInfo::Filename' has a wrong offset!");

// Function Phoenix.PhxDebugCameraDrawing.DrawAxes
// 0x0030 (0x0030 - 0x0000)
struct PhxDebugCameraDrawing_DrawAxes final
{
public:
	class UObject*                                World;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                Location;                                          // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               Rotation;                                          // 0x0014(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         Thickness;                                         // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Scale;                                             // 0x0024(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ColorScale;                                        // 0x0028(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugCameraDrawing_DrawAxes) == 0x000008, "Wrong alignment on PhxDebugCameraDrawing_DrawAxes");
static_assert(sizeof(PhxDebugCameraDrawing_DrawAxes) == 0x000030, "Wrong size on PhxDebugCameraDrawing_DrawAxes");
static_assert(offsetof(PhxDebugCameraDrawing_DrawAxes, World) == 0x000000, "Member 'PhxDebugCameraDrawing_DrawAxes::World' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawAxes, Location) == 0x000008, "Member 'PhxDebugCameraDrawing_DrawAxes::Location' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawAxes, Rotation) == 0x000014, "Member 'PhxDebugCameraDrawing_DrawAxes::Rotation' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawAxes, Thickness) == 0x000020, "Member 'PhxDebugCameraDrawing_DrawAxes::Thickness' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawAxes, Scale) == 0x000024, "Member 'PhxDebugCameraDrawing_DrawAxes::Scale' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawAxes, ColorScale) == 0x000028, "Member 'PhxDebugCameraDrawing_DrawAxes::ColorScale' has a wrong offset!");

// Function Phoenix.PhxDebugCameraDrawing.DrawFrustum
// 0x0038 (0x0038 - 0x0000)
struct PhxDebugCameraDrawing_DrawFrustum final
{
public:
	class UObject*                                World;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                Location;                                          // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               Rotation;                                          // 0x0014(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         fieldOfView;                                       // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ScreenRatio;                                       // 0x0024(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NearClip;                                          // 0x0028(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FarClip;                                           // 0x002C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Thickness;                                         // 0x0030(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugCameraDrawing_DrawFrustum) == 0x000008, "Wrong alignment on PhxDebugCameraDrawing_DrawFrustum");
static_assert(sizeof(PhxDebugCameraDrawing_DrawFrustum) == 0x000038, "Wrong size on PhxDebugCameraDrawing_DrawFrustum");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustum, World) == 0x000000, "Member 'PhxDebugCameraDrawing_DrawFrustum::World' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustum, Location) == 0x000008, "Member 'PhxDebugCameraDrawing_DrawFrustum::Location' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustum, Rotation) == 0x000014, "Member 'PhxDebugCameraDrawing_DrawFrustum::Rotation' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustum, fieldOfView) == 0x000020, "Member 'PhxDebugCameraDrawing_DrawFrustum::fieldOfView' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustum, ScreenRatio) == 0x000024, "Member 'PhxDebugCameraDrawing_DrawFrustum::ScreenRatio' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustum, NearClip) == 0x000028, "Member 'PhxDebugCameraDrawing_DrawFrustum::NearClip' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustum, FarClip) == 0x00002C, "Member 'PhxDebugCameraDrawing_DrawFrustum::FarClip' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustum, Thickness) == 0x000030, "Member 'PhxDebugCameraDrawing_DrawFrustum::Thickness' has a wrong offset!");

// Function Phoenix.PhxDebugCameraDrawing.DrawFrustumCollision
// 0x0038 (0x0038 - 0x0000)
struct PhxDebugCameraDrawing_DrawFrustumCollision final
{
public:
	class UObject*                                World;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                Location;                                          // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               Rotation;                                          // 0x0014(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         fieldOfView;                                       // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ScreenRatio;                                       // 0x0024(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NearClip;                                          // 0x0028(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FarClip;                                           // 0x002C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Thickness;                                         // 0x0030(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugCameraDrawing_DrawFrustumCollision) == 0x000008, "Wrong alignment on PhxDebugCameraDrawing_DrawFrustumCollision");
static_assert(sizeof(PhxDebugCameraDrawing_DrawFrustumCollision) == 0x000038, "Wrong size on PhxDebugCameraDrawing_DrawFrustumCollision");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustumCollision, World) == 0x000000, "Member 'PhxDebugCameraDrawing_DrawFrustumCollision::World' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustumCollision, Location) == 0x000008, "Member 'PhxDebugCameraDrawing_DrawFrustumCollision::Location' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustumCollision, Rotation) == 0x000014, "Member 'PhxDebugCameraDrawing_DrawFrustumCollision::Rotation' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustumCollision, fieldOfView) == 0x000020, "Member 'PhxDebugCameraDrawing_DrawFrustumCollision::fieldOfView' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustumCollision, ScreenRatio) == 0x000024, "Member 'PhxDebugCameraDrawing_DrawFrustumCollision::ScreenRatio' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustumCollision, NearClip) == 0x000028, "Member 'PhxDebugCameraDrawing_DrawFrustumCollision::NearClip' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustumCollision, FarClip) == 0x00002C, "Member 'PhxDebugCameraDrawing_DrawFrustumCollision::FarClip' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawFrustumCollision, Thickness) == 0x000030, "Member 'PhxDebugCameraDrawing_DrawFrustumCollision::Thickness' has a wrong offset!");

// Function Phoenix.PhxDebugCameraDrawing.DrawOutlinedText
// 0x0058 (0x0058 - 0x0000)
struct PhxDebugCameraDrawing_DrawOutlinedText final
{
public:
	class UObject*                                World;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Text;                                              // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                Location;                                          // 0x0018(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               ViewRotation;                                      // 0x0024(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           TextColor;                                         // 0x0030(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           OutlineColor;                                      // 0x0040(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OutlineOffset;                                     // 0x0050(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_54[0x4];                                       // 0x0054(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDebugCameraDrawing_DrawOutlinedText) == 0x000008, "Wrong alignment on PhxDebugCameraDrawing_DrawOutlinedText");
static_assert(sizeof(PhxDebugCameraDrawing_DrawOutlinedText) == 0x000058, "Wrong size on PhxDebugCameraDrawing_DrawOutlinedText");
static_assert(offsetof(PhxDebugCameraDrawing_DrawOutlinedText, World) == 0x000000, "Member 'PhxDebugCameraDrawing_DrawOutlinedText::World' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawOutlinedText, Text) == 0x000008, "Member 'PhxDebugCameraDrawing_DrawOutlinedText::Text' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawOutlinedText, Location) == 0x000018, "Member 'PhxDebugCameraDrawing_DrawOutlinedText::Location' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawOutlinedText, ViewRotation) == 0x000024, "Member 'PhxDebugCameraDrawing_DrawOutlinedText::ViewRotation' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawOutlinedText, TextColor) == 0x000030, "Member 'PhxDebugCameraDrawing_DrawOutlinedText::TextColor' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawOutlinedText, OutlineColor) == 0x000040, "Member 'PhxDebugCameraDrawing_DrawOutlinedText::OutlineColor' has a wrong offset!");
static_assert(offsetof(PhxDebugCameraDrawing_DrawOutlinedText, OutlineOffset) == 0x000050, "Member 'PhxDebugCameraDrawing_DrawOutlinedText::OutlineOffset' has a wrong offset!");

// Function Phoenix.PhxDialogueEvent.GetCurrentlySpeakingActor
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueEvent_GetCurrentlySpeakingActor final
{
public:
	class AActor*                                 ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueEvent_GetCurrentlySpeakingActor) == 0x000008, "Wrong alignment on PhxDialogueEvent_GetCurrentlySpeakingActor");
static_assert(sizeof(PhxDialogueEvent_GetCurrentlySpeakingActor) == 0x000008, "Wrong size on PhxDialogueEvent_GetCurrentlySpeakingActor");
static_assert(offsetof(PhxDialogueEvent_GetCurrentlySpeakingActor, ReturnValue) == 0x000000, "Member 'PhxDialogueEvent_GetCurrentlySpeakingActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDialogueEvent.GetSoundComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueEvent_GetSoundComponent final
{
public:
	class UPhxSoundComponent*                     ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueEvent_GetSoundComponent) == 0x000008, "Wrong alignment on PhxDialogueEvent_GetSoundComponent");
static_assert(sizeof(PhxDialogueEvent_GetSoundComponent) == 0x000008, "Wrong size on PhxDialogueEvent_GetSoundComponent");
static_assert(offsetof(PhxDialogueEvent_GetSoundComponent, ReturnValue) == 0x000000, "Member 'PhxDialogueEvent_GetSoundComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDialogueEvent.OnSoundEventCallback
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueEvent_OnSoundEventCallback final
{
public:
	EAkCallbackType                               CallbackType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UAkCallbackInfo*                        CallbackInfo;                                      // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueEvent_OnSoundEventCallback) == 0x000008, "Wrong alignment on PhxDialogueEvent_OnSoundEventCallback");
static_assert(sizeof(PhxDialogueEvent_OnSoundEventCallback) == 0x000010, "Wrong size on PhxDialogueEvent_OnSoundEventCallback");
static_assert(offsetof(PhxDialogueEvent_OnSoundEventCallback, CallbackType) == 0x000000, "Member 'PhxDialogueEvent_OnSoundEventCallback::CallbackType' has a wrong offset!");
static_assert(offsetof(PhxDialogueEvent_OnSoundEventCallback, CallbackInfo) == 0x000008, "Member 'PhxDialogueEvent_OnSoundEventCallback::CallbackInfo' has a wrong offset!");

// Function Phoenix.PhxDialogueEvent.PausePhxSoundEvent
// 0x0004 (0x0004 - 0x0000)
struct PhxDialogueEvent_PausePhxSoundEvent final
{
public:
	int32                                         FadeTime;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueEvent_PausePhxSoundEvent) == 0x000004, "Wrong alignment on PhxDialogueEvent_PausePhxSoundEvent");
static_assert(sizeof(PhxDialogueEvent_PausePhxSoundEvent) == 0x000004, "Wrong size on PhxDialogueEvent_PausePhxSoundEvent");
static_assert(offsetof(PhxDialogueEvent_PausePhxSoundEvent, FadeTime) == 0x000000, "Member 'PhxDialogueEvent_PausePhxSoundEvent::FadeTime' has a wrong offset!");

// Function Phoenix.PhxDialogueEvent.ResumePhxSoundEvent
// 0x0004 (0x0004 - 0x0000)
struct PhxDialogueEvent_ResumePhxSoundEvent final
{
public:
	int32                                         FadeTime;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueEvent_ResumePhxSoundEvent) == 0x000004, "Wrong alignment on PhxDialogueEvent_ResumePhxSoundEvent");
static_assert(sizeof(PhxDialogueEvent_ResumePhxSoundEvent) == 0x000004, "Wrong size on PhxDialogueEvent_ResumePhxSoundEvent");
static_assert(offsetof(PhxDialogueEvent_ResumePhxSoundEvent, FadeTime) == 0x000000, "Member 'PhxDialogueEvent_ResumePhxSoundEvent::FadeTime' has a wrong offset!");

// Function Phoenix.PhxDialogueEvent.StopPhxSoundEvent
// 0x0004 (0x0004 - 0x0000)
struct PhxDialogueEvent_StopPhxSoundEvent final
{
public:
	int32                                         FadeTime;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueEvent_StopPhxSoundEvent) == 0x000004, "Wrong alignment on PhxDialogueEvent_StopPhxSoundEvent");
static_assert(sizeof(PhxDialogueEvent_StopPhxSoundEvent) == 0x000004, "Wrong size on PhxDialogueEvent_StopPhxSoundEvent");
static_assert(offsetof(PhxDialogueEvent_StopPhxSoundEvent, FadeTime) == 0x000000, "Member 'PhxDialogueEvent_StopPhxSoundEvent::FadeTime' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxDialogueManager*                    ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_Get) == 0x000008, "Wrong alignment on PhxDialogueManager_Get");
static_assert(sizeof(PhxDialogueManager_Get) == 0x000010, "Wrong size on PhxDialogueManager_Get");
static_assert(offsetof(PhxDialogueManager_Get, WorldContextObject) == 0x000000, "Member 'PhxDialogueManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_Get, ReturnValue) == 0x000008, "Member 'PhxDialogueManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.AreSubtitlesDisabled
// 0x0001 (0x0001 - 0x0000)
struct PhxDialogueManager_AreSubtitlesDisabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_AreSubtitlesDisabled) == 0x000001, "Wrong alignment on PhxDialogueManager_AreSubtitlesDisabled");
static_assert(sizeof(PhxDialogueManager_AreSubtitlesDisabled) == 0x000001, "Wrong size on PhxDialogueManager_AreSubtitlesDisabled");
static_assert(offsetof(PhxDialogueManager_AreSubtitlesDisabled, ReturnValue) == 0x000000, "Member 'PhxDialogueManager_AreSubtitlesDisabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.OnCombatStateChanged
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueManager_OnCombatStateChanged final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               PreviousGameState;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               NewGameState;                                      // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDialogueManager_OnCombatStateChanged) == 0x000008, "Wrong alignment on PhxDialogueManager_OnCombatStateChanged");
static_assert(sizeof(PhxDialogueManager_OnCombatStateChanged) == 0x000010, "Wrong size on PhxDialogueManager_OnCombatStateChanged");
static_assert(offsetof(PhxDialogueManager_OnCombatStateChanged, GameStateManager) == 0x000000, "Member 'PhxDialogueManager_OnCombatStateChanged::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnCombatStateChanged, PreviousGameState) == 0x000008, "Member 'PhxDialogueManager_OnCombatStateChanged::PreviousGameState' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnCombatStateChanged, NewGameState) == 0x000009, "Member 'PhxDialogueManager_OnCombatStateChanged::NewGameState' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.OnEnemyDied
// 0x0018 (0x0018 - 0x0000)
struct PhxDialogueManager_OnEnemyDied final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_OnEnemyDied) == 0x000008, "Wrong alignment on PhxDialogueManager_OnEnemyDied");
static_assert(sizeof(PhxDialogueManager_OnEnemyDied) == 0x000018, "Wrong size on PhxDialogueManager_OnEnemyDied");
static_assert(offsetof(PhxDialogueManager_OnEnemyDied, GameStateManager) == 0x000000, "Member 'PhxDialogueManager_OnEnemyDied::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnEnemyDied, Enemy) == 0x000008, "Member 'PhxDialogueManager_OnEnemyDied::Enemy' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnEnemyDied, KillerController) == 0x000010, "Member 'PhxDialogueManager_OnEnemyDied::KillerController' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.OnEnemyMutated
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueManager_OnEnemyMutated final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_OnEnemyMutated) == 0x000008, "Wrong alignment on PhxDialogueManager_OnEnemyMutated");
static_assert(sizeof(PhxDialogueManager_OnEnemyMutated) == 0x000010, "Wrong size on PhxDialogueManager_OnEnemyMutated");
static_assert(offsetof(PhxDialogueManager_OnEnemyMutated, GameStateManager) == 0x000000, "Member 'PhxDialogueManager_OnEnemyMutated::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnEnemyMutated, Enemy) == 0x000008, "Member 'PhxDialogueManager_OnEnemyMutated::Enemy' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.OnLastEncounterEnemyDied
// 0x0018 (0x0018 - 0x0000)
struct PhxDialogueManager_OnLastEncounterEnemyDied final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_OnLastEncounterEnemyDied) == 0x000008, "Wrong alignment on PhxDialogueManager_OnLastEncounterEnemyDied");
static_assert(sizeof(PhxDialogueManager_OnLastEncounterEnemyDied) == 0x000018, "Wrong size on PhxDialogueManager_OnLastEncounterEnemyDied");
static_assert(offsetof(PhxDialogueManager_OnLastEncounterEnemyDied, GameStateManager) == 0x000000, "Member 'PhxDialogueManager_OnLastEncounterEnemyDied::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnLastEncounterEnemyDied, Enemy) == 0x000008, "Member 'PhxDialogueManager_OnLastEncounterEnemyDied::Enemy' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnLastEncounterEnemyDied, KillerController) == 0x000010, "Member 'PhxDialogueManager_OnLastEncounterEnemyDied::KillerController' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.OnPlayerFiredWeapon
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueManager_OnPlayerFiredWeapon final
{
public:
	class APhxPlayerCharacter*                    Player;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxGunWeapon*                          Weapon;                                            // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_OnPlayerFiredWeapon) == 0x000008, "Wrong alignment on PhxDialogueManager_OnPlayerFiredWeapon");
static_assert(sizeof(PhxDialogueManager_OnPlayerFiredWeapon) == 0x000010, "Wrong size on PhxDialogueManager_OnPlayerFiredWeapon");
static_assert(offsetof(PhxDialogueManager_OnPlayerFiredWeapon, Player) == 0x000000, "Member 'PhxDialogueManager_OnPlayerFiredWeapon::Player' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnPlayerFiredWeapon, Weapon) == 0x000008, "Member 'PhxDialogueManager_OnPlayerFiredWeapon::Weapon' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.OnPlayerFocusTargetChanged
// 0x0018 (0x0018 - 0x0000)
struct PhxDialogueManager_OnPlayerFocusTargetChanged final
{
public:
	class APhxPlayerCharacter*                    Player;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 PreviousFocusTarget;                               // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 NewFocusTarget;                                    // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_OnPlayerFocusTargetChanged) == 0x000008, "Wrong alignment on PhxDialogueManager_OnPlayerFocusTargetChanged");
static_assert(sizeof(PhxDialogueManager_OnPlayerFocusTargetChanged) == 0x000018, "Wrong size on PhxDialogueManager_OnPlayerFocusTargetChanged");
static_assert(offsetof(PhxDialogueManager_OnPlayerFocusTargetChanged, Player) == 0x000000, "Member 'PhxDialogueManager_OnPlayerFocusTargetChanged::Player' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnPlayerFocusTargetChanged, PreviousFocusTarget) == 0x000008, "Member 'PhxDialogueManager_OnPlayerFocusTargetChanged::PreviousFocusTarget' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnPlayerFocusTargetChanged, NewFocusTarget) == 0x000010, "Member 'PhxDialogueManager_OnPlayerFocusTargetChanged::NewFocusTarget' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.OnPlayerInteractionExecuted
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueManager_OnPlayerInteractionExecuted final
{
public:
	class APhxCharacter*                          InteractingCharacter;                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UInteraction*                     Interaction;                                       // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_OnPlayerInteractionExecuted) == 0x000008, "Wrong alignment on PhxDialogueManager_OnPlayerInteractionExecuted");
static_assert(sizeof(PhxDialogueManager_OnPlayerInteractionExecuted) == 0x000010, "Wrong size on PhxDialogueManager_OnPlayerInteractionExecuted");
static_assert(offsetof(PhxDialogueManager_OnPlayerInteractionExecuted, InteractingCharacter) == 0x000000, "Member 'PhxDialogueManager_OnPlayerInteractionExecuted::InteractingCharacter' has a wrong offset!");
static_assert(offsetof(PhxDialogueManager_OnPlayerInteractionExecuted, Interaction) == 0x000008, "Member 'PhxDialogueManager_OnPlayerInteractionExecuted::Interaction' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.OnSoundEventEnd
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueManager_OnSoundEventEnd final
{
public:
	class UPhxDialogueEvent*                      DialogueEvent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_OnSoundEventEnd) == 0x000008, "Wrong alignment on PhxDialogueManager_OnSoundEventEnd");
static_assert(sizeof(PhxDialogueManager_OnSoundEventEnd) == 0x000008, "Wrong size on PhxDialogueManager_OnSoundEventEnd");
static_assert(offsetof(PhxDialogueManager_OnSoundEventEnd, DialogueEvent) == 0x000000, "Member 'PhxDialogueManager_OnSoundEventEnd::DialogueEvent' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.UpdateBinkSubtitle
// 0x0138 (0x0138 - 0x0000)
struct PhxDialogueManager_UpdateBinkSubtitle final
{
public:
	struct FBinkSubtitleRow                       InRow;                                             // 0x0000(0x0138)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_UpdateBinkSubtitle) == 0x000008, "Wrong alignment on PhxDialogueManager_UpdateBinkSubtitle");
static_assert(sizeof(PhxDialogueManager_UpdateBinkSubtitle) == 0x000138, "Wrong size on PhxDialogueManager_UpdateBinkSubtitle");
static_assert(offsetof(PhxDialogueManager_UpdateBinkSubtitle, InRow) == 0x000000, "Member 'PhxDialogueManager_UpdateBinkSubtitle::InRow' has a wrong offset!");

// Function Phoenix.PhxDialogueManager.UpdateSubtitles
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueManager_UpdateSubtitles final
{
public:
	class UPhxDialogueEvent*                      DialogueEvent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueManager_UpdateSubtitles) == 0x000008, "Wrong alignment on PhxDialogueManager_UpdateSubtitles");
static_assert(sizeof(PhxDialogueManager_UpdateSubtitles) == 0x000008, "Wrong size on PhxDialogueManager_UpdateSubtitles");
static_assert(offsetof(PhxDialogueManager_UpdateSubtitles, DialogueEvent) == 0x000000, "Member 'PhxDialogueManager_UpdateSubtitles::DialogueEvent' has a wrong offset!");

// Function Phoenix.PhxDialogueWorldSubsystem.PauseAudioLog
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueWorldSubsystem_PauseAudioLog final
{
public:
	class UDialogue*                              InAudioLog;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueWorldSubsystem_PauseAudioLog) == 0x000008, "Wrong alignment on PhxDialogueWorldSubsystem_PauseAudioLog");
static_assert(sizeof(PhxDialogueWorldSubsystem_PauseAudioLog) == 0x000008, "Wrong size on PhxDialogueWorldSubsystem_PauseAudioLog");
static_assert(offsetof(PhxDialogueWorldSubsystem_PauseAudioLog, InAudioLog) == 0x000000, "Member 'PhxDialogueWorldSubsystem_PauseAudioLog::InAudioLog' has a wrong offset!");

// Function Phoenix.PhxDialogueWorldSubsystem.PlayAudioLog
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueWorldSubsystem_PlayAudioLog final
{
public:
	class UDialogue*                              InAudioLog;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Speaker;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueWorldSubsystem_PlayAudioLog) == 0x000008, "Wrong alignment on PhxDialogueWorldSubsystem_PlayAudioLog");
static_assert(sizeof(PhxDialogueWorldSubsystem_PlayAudioLog) == 0x000010, "Wrong size on PhxDialogueWorldSubsystem_PlayAudioLog");
static_assert(offsetof(PhxDialogueWorldSubsystem_PlayAudioLog, InAudioLog) == 0x000000, "Member 'PhxDialogueWorldSubsystem_PlayAudioLog::InAudioLog' has a wrong offset!");
static_assert(offsetof(PhxDialogueWorldSubsystem_PlayAudioLog, Speaker) == 0x000008, "Member 'PhxDialogueWorldSubsystem_PlayAudioLog::Speaker' has a wrong offset!");

// Function Phoenix.PhxDialogueWorldSubsystem.PlayDialogue
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueWorldSubsystem_PlayDialogue final
{
public:
	class UDialogue*                              InDialogue;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 SpeakingActor;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueWorldSubsystem_PlayDialogue) == 0x000008, "Wrong alignment on PhxDialogueWorldSubsystem_PlayDialogue");
static_assert(sizeof(PhxDialogueWorldSubsystem_PlayDialogue) == 0x000010, "Wrong size on PhxDialogueWorldSubsystem_PlayDialogue");
static_assert(offsetof(PhxDialogueWorldSubsystem_PlayDialogue, InDialogue) == 0x000000, "Member 'PhxDialogueWorldSubsystem_PlayDialogue::InDialogue' has a wrong offset!");
static_assert(offsetof(PhxDialogueWorldSubsystem_PlayDialogue, SpeakingActor) == 0x000008, "Member 'PhxDialogueWorldSubsystem_PlayDialogue::SpeakingActor' has a wrong offset!");

// Function Phoenix.PhxDialogueWorldSubsystem.StopAudioLog
// 0x0008 (0x0008 - 0x0000)
struct PhxDialogueWorldSubsystem_StopAudioLog final
{
public:
	class UDialogue*                              InAudioLog;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDialogueWorldSubsystem_StopAudioLog) == 0x000008, "Wrong alignment on PhxDialogueWorldSubsystem_StopAudioLog");
static_assert(sizeof(PhxDialogueWorldSubsystem_StopAudioLog) == 0x000008, "Wrong size on PhxDialogueWorldSubsystem_StopAudioLog");
static_assert(offsetof(PhxDialogueWorldSubsystem_StopAudioLog, InAudioLog) == 0x000000, "Member 'PhxDialogueWorldSubsystem_StopAudioLog::InAudioLog' has a wrong offset!");

// Function Phoenix.PhxDialogueWorldSubsystem.TestCombatStateChange
// 0x0010 (0x0010 - 0x0000)
struct PhxDialogueWorldSubsystem_TestCombatStateChange final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               PreviousGameState;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               NewGameState;                                      // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDialogueWorldSubsystem_TestCombatStateChange) == 0x000008, "Wrong alignment on PhxDialogueWorldSubsystem_TestCombatStateChange");
static_assert(sizeof(PhxDialogueWorldSubsystem_TestCombatStateChange) == 0x000010, "Wrong size on PhxDialogueWorldSubsystem_TestCombatStateChange");
static_assert(offsetof(PhxDialogueWorldSubsystem_TestCombatStateChange, GameStateManager) == 0x000000, "Member 'PhxDialogueWorldSubsystem_TestCombatStateChange::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxDialogueWorldSubsystem_TestCombatStateChange, PreviousGameState) == 0x000008, "Member 'PhxDialogueWorldSubsystem_TestCombatStateChange::PreviousGameState' has a wrong offset!");
static_assert(offsetof(PhxDialogueWorldSubsystem_TestCombatStateChange, NewGameState) == 0x000009, "Member 'PhxDialogueWorldSubsystem_TestCombatStateChange::NewGameState' has a wrong offset!");

// Function Phoenix.PhxDynamicDropsActor.OnTriggerOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxDynamicDropsActor_OnTriggerOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDynamicDropsActor_OnTriggerOverlap) == 0x000008, "Wrong alignment on PhxDynamicDropsActor_OnTriggerOverlap");
static_assert(sizeof(PhxDynamicDropsActor_OnTriggerOverlap) == 0x0000A8, "Wrong size on PhxDynamicDropsActor_OnTriggerOverlap");
static_assert(offsetof(PhxDynamicDropsActor_OnTriggerOverlap, OverlappedComponent) == 0x000000, "Member 'PhxDynamicDropsActor_OnTriggerOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsActor_OnTriggerOverlap, OtherActor) == 0x000008, "Member 'PhxDynamicDropsActor_OnTriggerOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsActor_OnTriggerOverlap, OtherComp) == 0x000010, "Member 'PhxDynamicDropsActor_OnTriggerOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsActor_OnTriggerOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxDynamicDropsActor_OnTriggerOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsActor_OnTriggerOverlap, bFromSweep) == 0x00001C, "Member 'PhxDynamicDropsActor_OnTriggerOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsActor_OnTriggerOverlap, SweepResult) == 0x000020, "Member 'PhxDynamicDropsActor_OnTriggerOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxDynamicDropsActor.ScanForNearbySpawnNodes
// 0x0001 (0x0001 - 0x0000)
struct PhxDynamicDropsActor_ScanForNearbySpawnNodes final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDynamicDropsActor_ScanForNearbySpawnNodes) == 0x000001, "Wrong alignment on PhxDynamicDropsActor_ScanForNearbySpawnNodes");
static_assert(sizeof(PhxDynamicDropsActor_ScanForNearbySpawnNodes) == 0x000001, "Wrong size on PhxDynamicDropsActor_ScanForNearbySpawnNodes");
static_assert(offsetof(PhxDynamicDropsActor_ScanForNearbySpawnNodes, ReturnValue) == 0x000000, "Member 'PhxDynamicDropsActor_ScanForNearbySpawnNodes::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDynamicDropsActor.SpawnLoot
// 0x0008 (0x0008 - 0x0000)
struct PhxDynamicDropsActor_SpawnLoot final
{
public:
	class APhxPlayerCharacter*                    Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDynamicDropsActor_SpawnLoot) == 0x000008, "Wrong alignment on PhxDynamicDropsActor_SpawnLoot");
static_assert(sizeof(PhxDynamicDropsActor_SpawnLoot) == 0x000008, "Wrong size on PhxDynamicDropsActor_SpawnLoot");
static_assert(offsetof(PhxDynamicDropsActor_SpawnLoot, Character) == 0x000000, "Member 'PhxDynamicDropsActor_SpawnLoot::Character' has a wrong offset!");

// Function Phoenix.PhxDynamicDropsComponent.OnOwnerDeath
// 0x0020 (0x0020 - 0x0000)
struct PhxDynamicDropsComponent_OnOwnerDeath final
{
public:
	class APhxCharacter*                          CharacterOwner;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxDynamicDropsComponent_OnOwnerDeath) == 0x000008, "Wrong alignment on PhxDynamicDropsComponent_OnOwnerDeath");
static_assert(sizeof(PhxDynamicDropsComponent_OnOwnerDeath) == 0x000020, "Wrong size on PhxDynamicDropsComponent_OnOwnerDeath");
static_assert(offsetof(PhxDynamicDropsComponent_OnOwnerDeath, CharacterOwner) == 0x000000, "Member 'PhxDynamicDropsComponent_OnOwnerDeath::CharacterOwner' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsComponent_OnOwnerDeath, KillerActor) == 0x000008, "Member 'PhxDynamicDropsComponent_OnOwnerDeath::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsComponent_OnOwnerDeath, KillerController) == 0x000010, "Member 'PhxDynamicDropsComponent_OnOwnerDeath::KillerController' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsComponent_OnOwnerDeath, KillingBlowHealthDelta) == 0x000018, "Member 'PhxDynamicDropsComponent_OnOwnerDeath::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxDynamicDropsComponent.SpawnLootAtLocation
// 0x0028 (0x0028 - 0x0000)
struct PhxDynamicDropsComponent_SpawnLootAtLocation final
{
public:
	class APhxPlayerCharacter*                    Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ItemLocation;                                      // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               ItemRotation;                                      // 0x0014(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	class APickup*                                ReturnValue;                                       // 0x0020(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDynamicDropsComponent_SpawnLootAtLocation) == 0x000008, "Wrong alignment on PhxDynamicDropsComponent_SpawnLootAtLocation");
static_assert(sizeof(PhxDynamicDropsComponent_SpawnLootAtLocation) == 0x000028, "Wrong size on PhxDynamicDropsComponent_SpawnLootAtLocation");
static_assert(offsetof(PhxDynamicDropsComponent_SpawnLootAtLocation, Character) == 0x000000, "Member 'PhxDynamicDropsComponent_SpawnLootAtLocation::Character' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsComponent_SpawnLootAtLocation, ItemLocation) == 0x000008, "Member 'PhxDynamicDropsComponent_SpawnLootAtLocation::ItemLocation' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsComponent_SpawnLootAtLocation, ItemRotation) == 0x000014, "Member 'PhxDynamicDropsComponent_SpawnLootAtLocation::ItemRotation' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsComponent_SpawnLootAtLocation, ReturnValue) == 0x000020, "Member 'PhxDynamicDropsComponent_SpawnLootAtLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDynamicDropsComponent.SpawnLootWithArcMotion
// 0x0028 (0x0028 - 0x0000)
struct PhxDynamicDropsComponent_SpawnLootWithArcMotion final
{
public:
	class APhxPlayerCharacter*                    Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ItemLocation;                                      // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               ItemRotation;                                      // 0x0014(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	class APickup*                                ReturnValue;                                       // 0x0020(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDynamicDropsComponent_SpawnLootWithArcMotion) == 0x000008, "Wrong alignment on PhxDynamicDropsComponent_SpawnLootWithArcMotion");
static_assert(sizeof(PhxDynamicDropsComponent_SpawnLootWithArcMotion) == 0x000028, "Wrong size on PhxDynamicDropsComponent_SpawnLootWithArcMotion");
static_assert(offsetof(PhxDynamicDropsComponent_SpawnLootWithArcMotion, Character) == 0x000000, "Member 'PhxDynamicDropsComponent_SpawnLootWithArcMotion::Character' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsComponent_SpawnLootWithArcMotion, ItemLocation) == 0x000008, "Member 'PhxDynamicDropsComponent_SpawnLootWithArcMotion::ItemLocation' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsComponent_SpawnLootWithArcMotion, ItemRotation) == 0x000014, "Member 'PhxDynamicDropsComponent_SpawnLootWithArcMotion::ItemRotation' has a wrong offset!");
static_assert(offsetof(PhxDynamicDropsComponent_SpawnLootWithArcMotion, ReturnValue) == 0x000020, "Member 'PhxDynamicDropsComponent_SpawnLootWithArcMotion::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxDynamicDropsComponent.ShouldDropLoot
// 0x0001 (0x0001 - 0x0000)
struct PhxDynamicDropsComponent_ShouldDropLoot final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxDynamicDropsComponent_ShouldDropLoot) == 0x000001, "Wrong alignment on PhxDynamicDropsComponent_ShouldDropLoot");
static_assert(sizeof(PhxDynamicDropsComponent_ShouldDropLoot) == 0x000001, "Wrong size on PhxDynamicDropsComponent_ShouldDropLoot");
static_assert(offsetof(PhxDynamicDropsComponent_ShouldDropLoot, ReturnValue) == 0x000000, "Member 'PhxDynamicDropsComponent_ShouldDropLoot::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxEconomyUIInterface.ConfirmHold
// 0x0004 (0x0004 - 0x0000)
struct PhxEconomyUIInterface_ConfirmHold final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxEconomyUIInterface_ConfirmHold) == 0x000004, "Wrong alignment on PhxEconomyUIInterface_ConfirmHold");
static_assert(sizeof(PhxEconomyUIInterface_ConfirmHold) == 0x000004, "Wrong size on PhxEconomyUIInterface_ConfirmHold");
static_assert(offsetof(PhxEconomyUIInterface_ConfirmHold, DeltaTime) == 0x000000, "Member 'PhxEconomyUIInterface_ConfirmHold::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxEconomyUIInterface.DirectionInput
// 0x0001 (0x0001 - 0x0000)
struct PhxEconomyUIInterface_DirectionInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxEconomyUIInterface_DirectionInput) == 0x000001, "Wrong alignment on PhxEconomyUIInterface_DirectionInput");
static_assert(sizeof(PhxEconomyUIInterface_DirectionInput) == 0x000001, "Wrong size on PhxEconomyUIInterface_DirectionInput");
static_assert(offsetof(PhxEconomyUIInterface_DirectionInput, Direction) == 0x000000, "Member 'PhxEconomyUIInterface_DirectionInput::Direction' has a wrong offset!");

// Function Phoenix.PhxEconomyUIInterface.FaceLeftHold
// 0x0004 (0x0004 - 0x0000)
struct PhxEconomyUIInterface_FaceLeftHold final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxEconomyUIInterface_FaceLeftHold) == 0x000004, "Wrong alignment on PhxEconomyUIInterface_FaceLeftHold");
static_assert(sizeof(PhxEconomyUIInterface_FaceLeftHold) == 0x000004, "Wrong size on PhxEconomyUIInterface_FaceLeftHold");
static_assert(offsetof(PhxEconomyUIInterface_FaceLeftHold, DeltaTime) == 0x000000, "Member 'PhxEconomyUIInterface_FaceLeftHold::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxEconomyUIInterface.FaceTopHold
// 0x0004 (0x0004 - 0x0000)
struct PhxEconomyUIInterface_FaceTopHold final
{
public:
	float                                         DeltaTime;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxEconomyUIInterface_FaceTopHold) == 0x000004, "Wrong alignment on PhxEconomyUIInterface_FaceTopHold");
static_assert(sizeof(PhxEconomyUIInterface_FaceTopHold) == 0x000004, "Wrong size on PhxEconomyUIInterface_FaceTopHold");
static_assert(offsetof(PhxEconomyUIInterface_FaceTopHold, DeltaTime) == 0x000000, "Member 'PhxEconomyUIInterface_FaceTopHold::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxEconomyUIInterface.SetParentInterfaceObject
// 0x0008 (0x0008 - 0x0000)
struct PhxEconomyUIInterface_SetParentInterfaceObject final
{
public:
	class UObject*                                Parent;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxEconomyUIInterface_SetParentInterfaceObject) == 0x000008, "Wrong alignment on PhxEconomyUIInterface_SetParentInterfaceObject");
static_assert(sizeof(PhxEconomyUIInterface_SetParentInterfaceObject) == 0x000008, "Wrong size on PhxEconomyUIInterface_SetParentInterfaceObject");
static_assert(offsetof(PhxEconomyUIInterface_SetParentInterfaceObject, Parent) == 0x000000, "Member 'PhxEconomyUIInterface_SetParentInterfaceObject::Parent' has a wrong offset!");

// Function Phoenix.PhxEconomyUIInterface.GetDeepestUI
// 0x0008 (0x0008 - 0x0000)
struct PhxEconomyUIInterface_GetDeepestUI final
{
public:
	class UObject*                                ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxEconomyUIInterface_GetDeepestUI) == 0x000008, "Wrong alignment on PhxEconomyUIInterface_GetDeepestUI");
static_assert(sizeof(PhxEconomyUIInterface_GetDeepestUI) == 0x000008, "Wrong size on PhxEconomyUIInterface_GetDeepestUI");
static_assert(offsetof(PhxEconomyUIInterface_GetDeepestUI, ReturnValue) == 0x000000, "Member 'PhxEconomyUIInterface_GetDeepestUI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxEconomyUIInterface.IsTopLevel
// 0x0001 (0x0001 - 0x0000)
struct PhxEconomyUIInterface_IsTopLevel final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxEconomyUIInterface_IsTopLevel) == 0x000001, "Wrong alignment on PhxEconomyUIInterface_IsTopLevel");
static_assert(sizeof(PhxEconomyUIInterface_IsTopLevel) == 0x000001, "Wrong size on PhxEconomyUIInterface_IsTopLevel");
static_assert(offsetof(PhxEconomyUIInterface_IsTopLevel, ReturnValue) == 0x000000, "Member 'PhxEconomyUIInterface_IsTopLevel::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHasEntitlementArray.HasEntitlements
// 0x0018 (0x0018 - 0x0000)
struct PhxHasEntitlementArray_HasEntitlements final
{
public:
	TArray<EPhxEntitlement>                       InEntitlements;                                    // 0x0000(0x0010)(Parm, ZeroConstructor, NativeAccessSpecifierPublic)
	class UPhxHasEntitlementArray*                ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasEntitlementArray_HasEntitlements) == 0x000008, "Wrong alignment on PhxHasEntitlementArray_HasEntitlements");
static_assert(sizeof(PhxHasEntitlementArray_HasEntitlements) == 0x000018, "Wrong size on PhxHasEntitlementArray_HasEntitlements");
static_assert(offsetof(PhxHasEntitlementArray_HasEntitlements, InEntitlements) == 0x000000, "Member 'PhxHasEntitlementArray_HasEntitlements::InEntitlements' has a wrong offset!");
static_assert(offsetof(PhxHasEntitlementArray_HasEntitlements, ReturnValue) == 0x000010, "Member 'PhxHasEntitlementArray_HasEntitlements::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxHasEntitlementArray.HandleFetchEntitlements
// 0x0050 (0x0050 - 0x0000)
struct PhxHasEntitlementArray_HandleFetchEntitlements final
{
public:
	struct FPhxEntitlementOwnership               Ownership;                                         // 0x0000(0x0050)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasEntitlementArray_HandleFetchEntitlements) == 0x000008, "Wrong alignment on PhxHasEntitlementArray_HandleFetchEntitlements");
static_assert(sizeof(PhxHasEntitlementArray_HandleFetchEntitlements) == 0x000050, "Wrong size on PhxHasEntitlementArray_HandleFetchEntitlements");
static_assert(offsetof(PhxHasEntitlementArray_HandleFetchEntitlements, Ownership) == 0x000000, "Member 'PhxHasEntitlementArray_HandleFetchEntitlements::Ownership' has a wrong offset!");

// Function Phoenix.PhxHasEntitlementArray.HandleFetchOnlineAccount
// 0x0010 (0x0010 - 0x0000)
struct PhxHasEntitlementArray_HandleFetchOnlineAccount final
{
public:
	bool                                          bSuccess;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	const class USDSOnlineAccount*                OnlineAccount;                                     // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxHasEntitlementArray_HandleFetchOnlineAccount) == 0x000008, "Wrong alignment on PhxHasEntitlementArray_HandleFetchOnlineAccount");
static_assert(sizeof(PhxHasEntitlementArray_HandleFetchOnlineAccount) == 0x000010, "Wrong size on PhxHasEntitlementArray_HandleFetchOnlineAccount");
static_assert(offsetof(PhxHasEntitlementArray_HandleFetchOnlineAccount, bSuccess) == 0x000000, "Member 'PhxHasEntitlementArray_HandleFetchOnlineAccount::bSuccess' has a wrong offset!");
static_assert(offsetof(PhxHasEntitlementArray_HandleFetchOnlineAccount, OnlineAccount) == 0x000008, "Member 'PhxHasEntitlementArray_HandleFetchOnlineAccount::OnlineAccount' has a wrong offset!");

// Function Phoenix.PhxEnvironmentalGoreComponent.OnBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxEnvironmentalGoreComponent_OnBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxEnvironmentalGoreComponent_OnBeginOverlap) == 0x000008, "Wrong alignment on PhxEnvironmentalGoreComponent_OnBeginOverlap");
static_assert(sizeof(PhxEnvironmentalGoreComponent_OnBeginOverlap) == 0x0000A8, "Wrong size on PhxEnvironmentalGoreComponent_OnBeginOverlap");
static_assert(offsetof(PhxEnvironmentalGoreComponent_OnBeginOverlap, OverlappedComponent) == 0x000000, "Member 'PhxEnvironmentalGoreComponent_OnBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxEnvironmentalGoreComponent_OnBeginOverlap, OtherActor) == 0x000008, "Member 'PhxEnvironmentalGoreComponent_OnBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxEnvironmentalGoreComponent_OnBeginOverlap, OtherComp) == 0x000010, "Member 'PhxEnvironmentalGoreComponent_OnBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxEnvironmentalGoreComponent_OnBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxEnvironmentalGoreComponent_OnBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxEnvironmentalGoreComponent_OnBeginOverlap, bFromSweep) == 0x00001C, "Member 'PhxEnvironmentalGoreComponent_OnBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxEnvironmentalGoreComponent_OnBeginOverlap, SweepResult) == 0x000020, "Member 'PhxEnvironmentalGoreComponent_OnBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.TraversalAbilityState.OnTraversalAbilityEnded
// 0x000C (0x000C - 0x0000)
struct TraversalAbilityState_OnTraversalAbilityEnded final
{
public:
	struct FGameplayTag                           InTag;                                             // 0x0000(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NewCount;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TraversalAbilityState_OnTraversalAbilityEnded) == 0x000004, "Wrong alignment on TraversalAbilityState_OnTraversalAbilityEnded");
static_assert(sizeof(TraversalAbilityState_OnTraversalAbilityEnded) == 0x00000C, "Wrong size on TraversalAbilityState_OnTraversalAbilityEnded");
static_assert(offsetof(TraversalAbilityState_OnTraversalAbilityEnded, InTag) == 0x000000, "Member 'TraversalAbilityState_OnTraversalAbilityEnded::InTag' has a wrong offset!");
static_assert(offsetof(TraversalAbilityState_OnTraversalAbilityEnded, NewCount) == 0x000008, "Member 'TraversalAbilityState_OnTraversalAbilityEnded::NewCount' has a wrong offset!");

// Function Phoenix.PhxFlashlight.OnFlashlightColorUpdated
// 0x0010 (0x0010 - 0x0000)
struct PhxFlashlight_OnFlashlightColorUpdated final
{
public:
	struct FLinearColor                           NewColor;                                          // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFlashlight_OnFlashlightColorUpdated) == 0x000004, "Wrong alignment on PhxFlashlight_OnFlashlightColorUpdated");
static_assert(sizeof(PhxFlashlight_OnFlashlightColorUpdated) == 0x000010, "Wrong size on PhxFlashlight_OnFlashlightColorUpdated");
static_assert(offsetof(PhxFlashlight_OnFlashlightColorUpdated, NewColor) == 0x000000, "Member 'PhxFlashlight_OnFlashlightColorUpdated::NewColor' has a wrong offset!");

// Function Phoenix.PhxFlashlight.OnVFXConeAlphaUpdated
// 0x0008 (0x0008 - 0x0000)
struct PhxFlashlight_OnVFXConeAlphaUpdated final
{
public:
	float                                         NewAlpha;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NewEmissiveMultiplier;                             // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFlashlight_OnVFXConeAlphaUpdated) == 0x000004, "Wrong alignment on PhxFlashlight_OnVFXConeAlphaUpdated");
static_assert(sizeof(PhxFlashlight_OnVFXConeAlphaUpdated) == 0x000008, "Wrong size on PhxFlashlight_OnVFXConeAlphaUpdated");
static_assert(offsetof(PhxFlashlight_OnVFXConeAlphaUpdated, NewAlpha) == 0x000000, "Member 'PhxFlashlight_OnVFXConeAlphaUpdated::NewAlpha' has a wrong offset!");
static_assert(offsetof(PhxFlashlight_OnVFXConeAlphaUpdated, NewEmissiveMultiplier) == 0x000004, "Member 'PhxFlashlight_OnVFXConeAlphaUpdated::NewEmissiveMultiplier' has a wrong offset!");

// Function Phoenix.PhxFlashlight.OnVolumetricOnlyLightPropertiesUpdated
// 0x001C (0x001C - 0x0000)
struct PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated final
{
public:
	struct FVector                                NewRelativeLocation;                               // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               NewRelativeRotation;                               // 0x000C(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         VolumetricScatteringIntensity;                     // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated) == 0x000004, "Wrong alignment on PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated");
static_assert(sizeof(PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated) == 0x00001C, "Wrong size on PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated");
static_assert(offsetof(PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated, NewRelativeLocation) == 0x000000, "Member 'PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated::NewRelativeLocation' has a wrong offset!");
static_assert(offsetof(PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated, NewRelativeRotation) == 0x00000C, "Member 'PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated::NewRelativeRotation' has a wrong offset!");
static_assert(offsetof(PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated, VolumetricScatteringIntensity) == 0x000018, "Member 'PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated::VolumetricScatteringIntensity' has a wrong offset!");

// Function Phoenix.PhxFlashlightComponent.PopDynamicGlobalModifier
// 0x0008 (0x0008 - 0x0000)
struct PhxFlashlightComponent_PopDynamicGlobalModifier final
{
public:
	class UPhxFlashlightModifier*                 Modifier;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFlashlightComponent_PopDynamicGlobalModifier) == 0x000008, "Wrong alignment on PhxFlashlightComponent_PopDynamicGlobalModifier");
static_assert(sizeof(PhxFlashlightComponent_PopDynamicGlobalModifier) == 0x000008, "Wrong size on PhxFlashlightComponent_PopDynamicGlobalModifier");
static_assert(offsetof(PhxFlashlightComponent_PopDynamicGlobalModifier, Modifier) == 0x000000, "Member 'PhxFlashlightComponent_PopDynamicGlobalModifier::Modifier' has a wrong offset!");

// Function Phoenix.PhxFlashlightComponent.PushDynamicGlobalModifier
// 0x0008 (0x0008 - 0x0000)
struct PhxFlashlightComponent_PushDynamicGlobalModifier final
{
public:
	class UPhxFlashlightModifier*                 Modifier;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFlashlightComponent_PushDynamicGlobalModifier) == 0x000008, "Wrong alignment on PhxFlashlightComponent_PushDynamicGlobalModifier");
static_assert(sizeof(PhxFlashlightComponent_PushDynamicGlobalModifier) == 0x000008, "Wrong size on PhxFlashlightComponent_PushDynamicGlobalModifier");
static_assert(offsetof(PhxFlashlightComponent_PushDynamicGlobalModifier, Modifier) == 0x000000, "Member 'PhxFlashlightComponent_PushDynamicGlobalModifier::Modifier' has a wrong offset!");

// Function Phoenix.PhxFlashlightComponent.PushDynamicGlobalModifierOfClass
// 0x0010 (0x0010 - 0x0000)
struct PhxFlashlightComponent_PushDynamicGlobalModifierOfClass final
{
public:
	TSubclassOf<class UPhxFlashlightModifier>     ModifierClass;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxFlashlightModifier*                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFlashlightComponent_PushDynamicGlobalModifierOfClass) == 0x000008, "Wrong alignment on PhxFlashlightComponent_PushDynamicGlobalModifierOfClass");
static_assert(sizeof(PhxFlashlightComponent_PushDynamicGlobalModifierOfClass) == 0x000010, "Wrong size on PhxFlashlightComponent_PushDynamicGlobalModifierOfClass");
static_assert(offsetof(PhxFlashlightComponent_PushDynamicGlobalModifierOfClass, ModifierClass) == 0x000000, "Member 'PhxFlashlightComponent_PushDynamicGlobalModifierOfClass::ModifierClass' has a wrong offset!");
static_assert(offsetof(PhxFlashlightComponent_PushDynamicGlobalModifierOfClass, ReturnValue) == 0x000008, "Member 'PhxFlashlightComponent_PushDynamicGlobalModifierOfClass::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxFlashlightComponent.GetBatteryModifier
// 0x0008 (0x0008 - 0x0000)
struct PhxFlashlightComponent_GetBatteryModifier final
{
public:
	class UPhxFlashlightModifier_Battery*         ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFlashlightComponent_GetBatteryModifier) == 0x000008, "Wrong alignment on PhxFlashlightComponent_GetBatteryModifier");
static_assert(sizeof(PhxFlashlightComponent_GetBatteryModifier) == 0x000008, "Wrong size on PhxFlashlightComponent_GetBatteryModifier");
static_assert(offsetof(PhxFlashlightComponent_GetBatteryModifier, ReturnValue) == 0x000000, "Member 'PhxFlashlightComponent_GetBatteryModifier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxFlashlightComponent.IsBatteryFullyDrained
// 0x0001 (0x0001 - 0x0000)
struct PhxFlashlightComponent_IsBatteryFullyDrained final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxFlashlightComponent_IsBatteryFullyDrained) == 0x000001, "Wrong alignment on PhxFlashlightComponent_IsBatteryFullyDrained");
static_assert(sizeof(PhxFlashlightComponent_IsBatteryFullyDrained) == 0x000001, "Wrong size on PhxFlashlightComponent_IsBatteryFullyDrained");
static_assert(offsetof(PhxFlashlightComponent_IsBatteryFullyDrained, ReturnValue) == 0x000000, "Member 'PhxFlashlightComponent_IsBatteryFullyDrained::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameInstance.GetCurrentServerName
// 0x0008 (0x0008 - 0x0000)
struct PhxGameInstance_GetCurrentServerName final
{
public:
	class FName                                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameInstance_GetCurrentServerName) == 0x000004, "Wrong alignment on PhxGameInstance_GetCurrentServerName");
static_assert(sizeof(PhxGameInstance_GetCurrentServerName) == 0x000008, "Wrong size on PhxGameInstance_GetCurrentServerName");
static_assert(offsetof(PhxGameInstance_GetCurrentServerName, ReturnValue) == 0x000000, "Member 'PhxGameInstance_GetCurrentServerName::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameInstance.GetSnowDeformEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameInstance_GetSnowDeformEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameInstance_GetSnowDeformEnabled) == 0x000001, "Wrong alignment on PhxGameInstance_GetSnowDeformEnabled");
static_assert(sizeof(PhxGameInstance_GetSnowDeformEnabled) == 0x000001, "Wrong size on PhxGameInstance_GetSnowDeformEnabled");
static_assert(offsetof(PhxGameInstance_GetSnowDeformEnabled, ReturnValue) == 0x000000, "Member 'PhxGameInstance_GetSnowDeformEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameInstance.SetSnowDeformEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameInstance_SetSnowDeformEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameInstance_SetSnowDeformEnabled) == 0x000001, "Wrong alignment on PhxGameInstance_SetSnowDeformEnabled");
static_assert(sizeof(PhxGameInstance_SetSnowDeformEnabled) == 0x000001, "Wrong size on PhxGameInstance_SetSnowDeformEnabled");
static_assert(offsetof(PhxGameInstance_SetSnowDeformEnabled, bEnable) == 0x000000, "Member 'PhxGameInstance_SetSnowDeformEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameInstance.StartDialogue
// 0x0010 (0x0010 - 0x0000)
struct PhxGameInstance_StartDialogue final
{
public:
	class UDialogue*                              InDialogue;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 NPCActor;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameInstance_StartDialogue) == 0x000008, "Wrong alignment on PhxGameInstance_StartDialogue");
static_assert(sizeof(PhxGameInstance_StartDialogue) == 0x000010, "Wrong size on PhxGameInstance_StartDialogue");
static_assert(offsetof(PhxGameInstance_StartDialogue, InDialogue) == 0x000000, "Member 'PhxGameInstance_StartDialogue::InDialogue' has a wrong offset!");
static_assert(offsetof(PhxGameInstance_StartDialogue, NPCActor) == 0x000008, "Member 'PhxGameInstance_StartDialogue::NPCActor' has a wrong offset!");

// Function Phoenix.PhxGameInstance.StartSession
// 0x0010 (0x0010 - 0x0000)
struct PhxGameInstance_StartSession final
{
public:
	class FString                                 SessionName;                                       // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameInstance_StartSession) == 0x000008, "Wrong alignment on PhxGameInstance_StartSession");
static_assert(sizeof(PhxGameInstance_StartSession) == 0x000010, "Wrong size on PhxGameInstance_StartSession");
static_assert(offsetof(PhxGameInstance_StartSession, SessionName) == 0x000000, "Member 'PhxGameInstance_StartSession::SessionName' has a wrong offset!");

// Function Phoenix.PhxGameInstance.GetBloodSpatterTraceManager
// 0x0008 (0x0008 - 0x0000)
struct PhxGameInstance_GetBloodSpatterTraceManager final
{
public:
	class UPhxBloodSpatterTraceManager*           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameInstance_GetBloodSpatterTraceManager) == 0x000008, "Wrong alignment on PhxGameInstance_GetBloodSpatterTraceManager");
static_assert(sizeof(PhxGameInstance_GetBloodSpatterTraceManager) == 0x000008, "Wrong size on PhxGameInstance_GetBloodSpatterTraceManager");
static_assert(offsetof(PhxGameInstance_GetBloodSpatterTraceManager, ReturnValue) == 0x000000, "Member 'PhxGameInstance_GetBloodSpatterTraceManager::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_ButtonHoldInteraction.OnInteractButtonHeld
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld final
{
public:
	float                                         TimeActive;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DeltaTime;                                         // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld) == 0x000004, "Wrong alignment on PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld");
static_assert(sizeof(PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld) == 0x000008, "Wrong size on PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld");
static_assert(offsetof(PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld, TimeActive) == 0x000000, "Member 'PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld::TimeActive' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld, DeltaTime) == 0x000004, "Member 'PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_ButtonHoldInteraction.OnInteractButtonReleased
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased final
{
public:
	float                                         TimeActive;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DeltaTime;                                         // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased) == 0x000004, "Wrong alignment on PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased");
static_assert(sizeof(PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased) == 0x000008, "Wrong size on PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased");
static_assert(offsetof(PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased, TimeActive) == 0x000000, "Member 'PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased::TimeActive' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased, DeltaTime) == 0x000004, "Member 'PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased::DeltaTime' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_CorpseStomp.OnNotifyStateBegin
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin final
{
public:
	const class UPhxAnimNotifyState*              NotifyState;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequenceBase*                      Animation;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin) == 0x000008, "Wrong alignment on PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin");
static_assert(sizeof(PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin) == 0x000010, "Wrong size on PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin");
static_assert(offsetof(PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin, NotifyState) == 0x000000, "Member 'PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin::NotifyState' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin, Animation) == 0x000008, "Member 'PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin::Animation' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_CorpseStomp.OnNotifyStateEnd
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd final
{
public:
	const class UPhxAnimNotifyState*              NotifyState;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequenceBase*                      Animation;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd) == 0x000008, "Wrong alignment on PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd");
static_assert(sizeof(PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd) == 0x000010, "Wrong size on PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd");
static_assert(offsetof(PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd, NotifyState) == 0x000000, "Member 'PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd::NotifyState' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd, Animation) == 0x000008, "Member 'PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd::Animation' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_CorpseStomp.OnStompTraceHit
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayAbility_CorpseStomp_OnStompTraceHit final
{
public:
	TArray<struct FHitResult>                     Hits;                                              // 0x0000(0x0010)(Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_CorpseStomp_OnStompTraceHit) == 0x000008, "Wrong alignment on PhxGameplayAbility_CorpseStomp_OnStompTraceHit");
static_assert(sizeof(PhxGameplayAbility_CorpseStomp_OnStompTraceHit) == 0x000010, "Wrong size on PhxGameplayAbility_CorpseStomp_OnStompTraceHit");
static_assert(offsetof(PhxGameplayAbility_CorpseStomp_OnStompTraceHit, Hits) == 0x000000, "Member 'PhxGameplayAbility_CorpseStomp_OnStompTraceHit::Hits' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_EchoScan.OnScanStopped
// 0x0010 (0x0010 - 0x0000)
struct PhxGameplayAbility_EchoScan_OnScanStopped final
{
public:
	class APhxCharacter*                          CaughtCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ScanDuration;                                      // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayAbility_EchoScan_OnScanStopped) == 0x000008, "Wrong alignment on PhxGameplayAbility_EchoScan_OnScanStopped");
static_assert(sizeof(PhxGameplayAbility_EchoScan_OnScanStopped) == 0x000010, "Wrong size on PhxGameplayAbility_EchoScan_OnScanStopped");
static_assert(offsetof(PhxGameplayAbility_EchoScan_OnScanStopped, CaughtCharacter) == 0x000000, "Member 'PhxGameplayAbility_EchoScan_OnScanStopped::CaughtCharacter' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_EchoScan_OnScanStopped, ScanDuration) == 0x000008, "Member 'PhxGameplayAbility_EchoScan_OnScanStopped::ScanDuration' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_FallToFloor.OnCharacterDeath
// 0x0020 (0x0020 - 0x0000)
struct PhxGameplayAbility_FallToFloor_OnCharacterDeath final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayAbility_FallToFloor_OnCharacterDeath) == 0x000008, "Wrong alignment on PhxGameplayAbility_FallToFloor_OnCharacterDeath");
static_assert(sizeof(PhxGameplayAbility_FallToFloor_OnCharacterDeath) == 0x000020, "Wrong size on PhxGameplayAbility_FallToFloor_OnCharacterDeath");
static_assert(offsetof(PhxGameplayAbility_FallToFloor_OnCharacterDeath, DeadCharacter) == 0x000000, "Member 'PhxGameplayAbility_FallToFloor_OnCharacterDeath::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_FallToFloor_OnCharacterDeath, KillerActor) == 0x000008, "Member 'PhxGameplayAbility_FallToFloor_OnCharacterDeath::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_FallToFloor_OnCharacterDeath, KillerController) == 0x000010, "Member 'PhxGameplayAbility_FallToFloor_OnCharacterDeath::KillerController' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_FallToFloor_OnCharacterDeath, KillingBlowHealthDelta) == 0x000018, "Member 'PhxGameplayAbility_FallToFloor_OnCharacterDeath::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_FallToFloor.OnMovementModeChanged
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayAbility_FallToFloor_OnMovementModeChanged final
{
public:
	EMovementMode                                 NewMovementMode;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_FallToFloor_OnMovementModeChanged) == 0x000001, "Wrong alignment on PhxGameplayAbility_FallToFloor_OnMovementModeChanged");
static_assert(sizeof(PhxGameplayAbility_FallToFloor_OnMovementModeChanged) == 0x000001, "Wrong size on PhxGameplayAbility_FallToFloor_OnMovementModeChanged");
static_assert(offsetof(PhxGameplayAbility_FallToFloor_OnMovementModeChanged, NewMovementMode) == 0x000000, "Member 'PhxGameplayAbility_FallToFloor_OnMovementModeChanged::NewMovementMode' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_GRPEnemyRecover.OnEnemyHit
// 0x00B0 (0x00B0 - 0x0000)
struct PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit) == 0x000008, "Wrong alignment on PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit");
static_assert(sizeof(PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit) == 0x0000B0, "Wrong size on PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit, HitComp) == 0x000000, "Member 'PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit::HitComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit, OtherActor) == 0x000008, "Member 'PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit, OtherComp) == 0x000010, "Member 'PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit, NormalImpulse) == 0x000018, "Member 'PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit, Hit) == 0x000024, "Member 'PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit::Hit' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_GRPEnemyRecover.OnMovementModeChanged
// 0x0001 (0x0001 - 0x0000)
struct PhxGameplayAbility_GRPEnemyRecover_OnMovementModeChanged final
{
public:
	EMovementMode                                 NewMovementMode;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_GRPEnemyRecover_OnMovementModeChanged) == 0x000001, "Wrong alignment on PhxGameplayAbility_GRPEnemyRecover_OnMovementModeChanged");
static_assert(sizeof(PhxGameplayAbility_GRPEnemyRecover_OnMovementModeChanged) == 0x000001, "Wrong size on PhxGameplayAbility_GRPEnemyRecover_OnMovementModeChanged");
static_assert(offsetof(PhxGameplayAbility_GRPEnemyRecover_OnMovementModeChanged, NewMovementMode) == 0x000000, "Member 'PhxGameplayAbility_GRPEnemyRecover_OnMovementModeChanged::NewMovementMode' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_PPEEnemyLift.OnEnemyHit
// 0x00B0 (0x00B0 - 0x0000)
struct PhxGameplayAbility_PPEEnemyLift_OnEnemyHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayAbility_PPEEnemyLift_OnEnemyHit) == 0x000008, "Wrong alignment on PhxGameplayAbility_PPEEnemyLift_OnEnemyHit");
static_assert(sizeof(PhxGameplayAbility_PPEEnemyLift_OnEnemyHit) == 0x0000B0, "Wrong size on PhxGameplayAbility_PPEEnemyLift_OnEnemyHit");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyLift_OnEnemyHit, HitComp) == 0x000000, "Member 'PhxGameplayAbility_PPEEnemyLift_OnEnemyHit::HitComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyLift_OnEnemyHit, OtherActor) == 0x000008, "Member 'PhxGameplayAbility_PPEEnemyLift_OnEnemyHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyLift_OnEnemyHit, OtherComp) == 0x000010, "Member 'PhxGameplayAbility_PPEEnemyLift_OnEnemyHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyLift_OnEnemyHit, NormalImpulse) == 0x000018, "Member 'PhxGameplayAbility_PPEEnemyLift_OnEnemyHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyLift_OnEnemyHit, Hit) == 0x000024, "Member 'PhxGameplayAbility_PPEEnemyLift_OnEnemyHit::Hit' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_PPEEnemyPull.OnEnemyHit
// 0x00B0 (0x00B0 - 0x0000)
struct PhxGameplayAbility_PPEEnemyPull_OnEnemyHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayAbility_PPEEnemyPull_OnEnemyHit) == 0x000008, "Wrong alignment on PhxGameplayAbility_PPEEnemyPull_OnEnemyHit");
static_assert(sizeof(PhxGameplayAbility_PPEEnemyPull_OnEnemyHit) == 0x0000B0, "Wrong size on PhxGameplayAbility_PPEEnemyPull_OnEnemyHit");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPull_OnEnemyHit, HitComp) == 0x000000, "Member 'PhxGameplayAbility_PPEEnemyPull_OnEnemyHit::HitComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPull_OnEnemyHit, OtherActor) == 0x000008, "Member 'PhxGameplayAbility_PPEEnemyPull_OnEnemyHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPull_OnEnemyHit, OtherComp) == 0x000010, "Member 'PhxGameplayAbility_PPEEnemyPull_OnEnemyHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPull_OnEnemyHit, NormalImpulse) == 0x000018, "Member 'PhxGameplayAbility_PPEEnemyPull_OnEnemyHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPull_OnEnemyHit, Hit) == 0x000024, "Member 'PhxGameplayAbility_PPEEnemyPull_OnEnemyHit::Hit' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_PPEEnemyPush.OnEnemyHit
// 0x00B0 (0x00B0 - 0x0000)
struct PhxGameplayAbility_PPEEnemyPush_OnEnemyHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameplayAbility_PPEEnemyPush_OnEnemyHit) == 0x000008, "Wrong alignment on PhxGameplayAbility_PPEEnemyPush_OnEnemyHit");
static_assert(sizeof(PhxGameplayAbility_PPEEnemyPush_OnEnemyHit) == 0x0000B0, "Wrong size on PhxGameplayAbility_PPEEnemyPush_OnEnemyHit");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPush_OnEnemyHit, HitComp) == 0x000000, "Member 'PhxGameplayAbility_PPEEnemyPush_OnEnemyHit::HitComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPush_OnEnemyHit, OtherActor) == 0x000008, "Member 'PhxGameplayAbility_PPEEnemyPush_OnEnemyHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPush_OnEnemyHit, OtherComp) == 0x000010, "Member 'PhxGameplayAbility_PPEEnemyPush_OnEnemyHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPush_OnEnemyHit, NormalImpulse) == 0x000018, "Member 'PhxGameplayAbility_PPEEnemyPush_OnEnemyHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PPEEnemyPush_OnEnemyHit, Hit) == 0x000024, "Member 'PhxGameplayAbility_PPEEnemyPush_OnEnemyHit::Hit' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_PuzzleSwitchInteraction.OnCharacterHealthModified
// 0x0028 (0x0028 - 0x0000)
struct PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified final
{
public:
	class UPhxHealthComponent*                    HealthComp;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HealthDelta;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified) == 0x000008, "Wrong alignment on PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified");
static_assert(sizeof(PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified) == 0x000028, "Wrong size on PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified");
static_assert(offsetof(PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified, HealthComp) == 0x000000, "Member 'PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified::HealthComp' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified, Health) == 0x000008, "Member 'PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified::Health' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified, HealthDelta) == 0x00000C, "Member 'PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified::HealthDelta' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified, DamageType) == 0x000010, "Member 'PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified::DamageType' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified, InstigatedBy) == 0x000018, "Member 'PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified, DamageCauser) == 0x000020, "Member 'PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_Reload.OnDefensiveActionInitiated
// 0x0100 (0x0100 - 0x0000)
struct PhxGameplayAbility_Reload_OnDefensiveActionInitiated final
{
public:
	EReactionType                                 ReactionType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefensiveReactDirection                      ReactionDir;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2[0x6];                                        // 0x0002(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitRecord                             HitRecord;                                         // 0x0008(0x00F8)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_Reload_OnDefensiveActionInitiated) == 0x000008, "Wrong alignment on PhxGameplayAbility_Reload_OnDefensiveActionInitiated");
static_assert(sizeof(PhxGameplayAbility_Reload_OnDefensiveActionInitiated) == 0x000100, "Wrong size on PhxGameplayAbility_Reload_OnDefensiveActionInitiated");
static_assert(offsetof(PhxGameplayAbility_Reload_OnDefensiveActionInitiated, ReactionType) == 0x000000, "Member 'PhxGameplayAbility_Reload_OnDefensiveActionInitiated::ReactionType' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_Reload_OnDefensiveActionInitiated, ReactionDir) == 0x000001, "Member 'PhxGameplayAbility_Reload_OnDefensiveActionInitiated::ReactionDir' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_Reload_OnDefensiveActionInitiated, HitRecord) == 0x000008, "Member 'PhxGameplayAbility_Reload_OnDefensiveActionInitiated::HitRecord' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_Reload.OnNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayAbility_Reload_OnNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_Reload_OnNotifyReceived) == 0x000008, "Wrong alignment on PhxGameplayAbility_Reload_OnNotifyReceived");
static_assert(sizeof(PhxGameplayAbility_Reload_OnNotifyReceived) == 0x000008, "Wrong size on PhxGameplayAbility_Reload_OnNotifyReceived");
static_assert(offsetof(PhxGameplayAbility_Reload_OnNotifyReceived, Notify) == 0x000000, "Member 'PhxGameplayAbility_Reload_OnNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_Stunned.OnDamageTaken
// 0x0028 (0x0028 - 0x0000)
struct PhxGameplayAbility_Stunned_OnDamageTaken final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_Stunned_OnDamageTaken) == 0x000008, "Wrong alignment on PhxGameplayAbility_Stunned_OnDamageTaken");
static_assert(sizeof(PhxGameplayAbility_Stunned_OnDamageTaken) == 0x000028, "Wrong size on PhxGameplayAbility_Stunned_OnDamageTaken");
static_assert(offsetof(PhxGameplayAbility_Stunned_OnDamageTaken, DamagedActor) == 0x000000, "Member 'PhxGameplayAbility_Stunned_OnDamageTaken::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_Stunned_OnDamageTaken, Damage) == 0x000008, "Member 'PhxGameplayAbility_Stunned_OnDamageTaken::Damage' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_Stunned_OnDamageTaken, DamageType) == 0x000010, "Member 'PhxGameplayAbility_Stunned_OnDamageTaken::DamageType' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_Stunned_OnDamageTaken, InstigatedBy) == 0x000018, "Member 'PhxGameplayAbility_Stunned_OnDamageTaken::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_Stunned_OnDamageTaken, DamageCauser) == 0x000020, "Member 'PhxGameplayAbility_Stunned_OnDamageTaken::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnDefensiveActionInitiated
// 0x0100 (0x0100 - 0x0000)
struct PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated final
{
public:
	EReactionType                                 ReactionType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefensiveReactDirection                      ReactionDir;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2[0x6];                                        // 0x0002(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitRecord                             HitRecord;                                         // 0x0008(0x00F8)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated) == 0x000008, "Wrong alignment on PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated");
static_assert(sizeof(PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated) == 0x000100, "Wrong size on PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated");
static_assert(offsetof(PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated, ReactionType) == 0x000000, "Member 'PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated::ReactionType' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated, ReactionDir) == 0x000001, "Member 'PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated::ReactionDir' has a wrong offset!");
static_assert(offsetof(PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated, HitRecord) == 0x000008, "Member 'PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated::HitRecord' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayAbility_SwapWeaponReceiver_OnNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_SwapWeaponReceiver_OnNotifyReceived) == 0x000008, "Wrong alignment on PhxGameplayAbility_SwapWeaponReceiver_OnNotifyReceived");
static_assert(sizeof(PhxGameplayAbility_SwapWeaponReceiver_OnNotifyReceived) == 0x000008, "Wrong size on PhxGameplayAbility_SwapWeaponReceiver_OnNotifyReceived");
static_assert(offsetof(PhxGameplayAbility_SwapWeaponReceiver_OnNotifyReceived, Notify) == 0x000000, "Member 'PhxGameplayAbility_SwapWeaponReceiver_OnNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxGameplayAbility_UnequipWeapon.OnNotifyReceived
// 0x0008 (0x0008 - 0x0000)
struct PhxGameplayAbility_UnequipWeapon_OnNotifyReceived final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameplayAbility_UnequipWeapon_OnNotifyReceived) == 0x000008, "Wrong alignment on PhxGameplayAbility_UnequipWeapon_OnNotifyReceived");
static_assert(sizeof(PhxGameplayAbility_UnequipWeapon_OnNotifyReceived) == 0x000008, "Wrong size on PhxGameplayAbility_UnequipWeapon_OnNotifyReceived");
static_assert(offsetof(PhxGameplayAbility_UnequipWeapon_OnNotifyReceived, Notify) == 0x000000, "Member 'PhxGameplayAbility_UnequipWeapon_OnNotifyReceived::Notify' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.AvailableScreenResolutions
// 0x0018 (0x0018 - 0x0000)
struct PhxGameUserSettings_AvailableScreenResolutions final
{
public:
	bool                                          bWindowed;                                         // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FIntPoint>                      ReturnValue;                                       // 0x0008(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_AvailableScreenResolutions) == 0x000008, "Wrong alignment on PhxGameUserSettings_AvailableScreenResolutions");
static_assert(sizeof(PhxGameUserSettings_AvailableScreenResolutions) == 0x000018, "Wrong size on PhxGameUserSettings_AvailableScreenResolutions");
static_assert(offsetof(PhxGameUserSettings_AvailableScreenResolutions, bWindowed) == 0x000000, "Member 'PhxGameUserSettings_AvailableScreenResolutions::bWindowed' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_AvailableScreenResolutions, ReturnValue) == 0x000008, "Member 'PhxGameUserSettings_AvailableScreenResolutions::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.Get
// 0x0008 (0x0008 - 0x0000)
struct PhxGameUserSettings_Get final
{
public:
	class UPhxGameUserSettings*                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_Get) == 0x000008, "Wrong alignment on PhxGameUserSettings_Get");
static_assert(sizeof(PhxGameUserSettings_Get) == 0x000008, "Wrong size on PhxGameUserSettings_Get");
static_assert(offsetof(PhxGameUserSettings_Get, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetAvailablePeakNits
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetAvailablePeakNits final
{
public:
	TArray<float>                                 ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetAvailablePeakNits) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetAvailablePeakNits");
static_assert(sizeof(PhxGameUserSettings_GetAvailablePeakNits) == 0x000010, "Wrong size on PhxGameUserSettings_GetAvailablePeakNits");
static_assert(offsetof(PhxGameUserSettings_GetAvailablePeakNits, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetAvailablePeakNits::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.AccumulateRiotCreditsSpent
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_AccumulateRiotCreditsSpent final
{
public:
	int32                                         Amount;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_AccumulateRiotCreditsSpent) == 0x000004, "Wrong alignment on PhxGameUserSettings_AccumulateRiotCreditsSpent");
static_assert(sizeof(PhxGameUserSettings_AccumulateRiotCreditsSpent) == 0x000004, "Wrong size on PhxGameUserSettings_AccumulateRiotCreditsSpent");
static_assert(offsetof(PhxGameUserSettings_AccumulateRiotCreditsSpent, Amount) == 0x000000, "Member 'PhxGameUserSettings_AccumulateRiotCreditsSpent::Amount' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.AddHighscore
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_AddHighscore final
{
public:
	struct FPhxHighScoreRecord                    InScore;                                           // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_AddHighscore) == 0x000008, "Wrong alignment on PhxGameUserSettings_AddHighscore");
static_assert(sizeof(PhxGameUserSettings_AddHighscore) == 0x000010, "Wrong size on PhxGameUserSettings_AddHighscore");
static_assert(offsetof(PhxGameUserSettings_AddHighscore, InScore) == 0x000000, "Member 'PhxGameUserSettings_AddHighscore::InScore' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.AddUnlockedRiotModePerk
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_AddUnlockedRiotModePerk final
{
public:
	EPhxRiotModePerkType                          Perk;                                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_AddUnlockedRiotModePerk) == 0x000001, "Wrong alignment on PhxGameUserSettings_AddUnlockedRiotModePerk");
static_assert(sizeof(PhxGameUserSettings_AddUnlockedRiotModePerk) == 0x000001, "Wrong size on PhxGameUserSettings_AddUnlockedRiotModePerk");
static_assert(offsetof(PhxGameUserSettings_AddUnlockedRiotModePerk, Perk) == 0x000000, "Member 'PhxGameUserSettings_AddUnlockedRiotModePerk::Perk' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.ClearRiotCreditsSpent
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_ClearRiotCreditsSpent final
{
public:
	int32                                         Amount;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_ClearRiotCreditsSpent) == 0x000004, "Wrong alignment on PhxGameUserSettings_ClearRiotCreditsSpent");
static_assert(sizeof(PhxGameUserSettings_ClearRiotCreditsSpent) == 0x000004, "Wrong size on PhxGameUserSettings_ClearRiotCreditsSpent");
static_assert(offsetof(PhxGameUserSettings_ClearRiotCreditsSpent, Amount) == 0x000000, "Member 'PhxGameUserSettings_ClearRiotCreditsSpent::Amount' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.EnableConsolePerformanceMode
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_EnableConsolePerformanceMode final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_EnableConsolePerformanceMode) == 0x000001, "Wrong alignment on PhxGameUserSettings_EnableConsolePerformanceMode");
static_assert(sizeof(PhxGameUserSettings_EnableConsolePerformanceMode) == 0x000001, "Wrong size on PhxGameUserSettings_EnableConsolePerformanceMode");
static_assert(offsetof(PhxGameUserSettings_EnableConsolePerformanceMode, bEnable) == 0x000000, "Member 'PhxGameUserSettings_EnableConsolePerformanceMode::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.PromptForDialogCultureChangeIfNecessary
// 0x0030 (0x0030 - 0x0000)
struct PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary final
{
public:
	class FString                                 CultureCode;                                       // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnConfirm;                                         // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnCancel;                                          // 0x0020(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary) == 0x000008, "Wrong alignment on PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary");
static_assert(sizeof(PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary) == 0x000030, "Wrong size on PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary");
static_assert(offsetof(PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary, CultureCode) == 0x000000, "Member 'PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary::CultureCode' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary, OnConfirm) == 0x000010, "Member 'PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary::OnConfirm' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary, OnCancel) == 0x000020, "Member 'PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary::OnCancel' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.PushActivatedTutorialTag
// 0x0008 (0x0008 - 0x0000)
struct PhxGameUserSettings_PushActivatedTutorialTag final
{
public:
	struct FGameplayTag                           TutorialTag;                                       // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_PushActivatedTutorialTag) == 0x000004, "Wrong alignment on PhxGameUserSettings_PushActivatedTutorialTag");
static_assert(sizeof(PhxGameUserSettings_PushActivatedTutorialTag) == 0x000008, "Wrong size on PhxGameUserSettings_PushActivatedTutorialTag");
static_assert(offsetof(PhxGameUserSettings_PushActivatedTutorialTag, TutorialTag) == 0x000000, "Member 'PhxGameUserSettings_PushActivatedTutorialTag::TutorialTag' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetAimAssistEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetAimAssistEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetAimAssistEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetAimAssistEnabled");
static_assert(sizeof(PhxGameUserSettings_SetAimAssistEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetAimAssistEnabled");
static_assert(offsetof(PhxGameUserSettings_SetAimAssistEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetAimAssistEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetAimAssistStrength
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetAimAssistStrength final
{
public:
	int32                                         Strenth;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetAimAssistStrength) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetAimAssistStrength");
static_assert(sizeof(PhxGameUserSettings_SetAimAssistStrength) == 0x000004, "Wrong size on PhxGameUserSettings_SetAimAssistStrength");
static_assert(offsetof(PhxGameUserSettings_SetAimAssistStrength, Strenth) == 0x000000, "Member 'PhxGameUserSettings_SetAimAssistStrength::Strenth' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetAimParallaxEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetAimParallaxEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetAimParallaxEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetAimParallaxEnabled");
static_assert(sizeof(PhxGameUserSettings_SetAimParallaxEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetAimParallaxEnabled");
static_assert(offsetof(PhxGameUserSettings_SetAimParallaxEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetAimParallaxEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetAimSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetAimSensitivity final
{
public:
	float                                         Sensitivity;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetAimSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetAimSensitivity");
static_assert(sizeof(PhxGameUserSettings_SetAimSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_SetAimSensitivity");
static_assert(offsetof(PhxGameUserSettings_SetAimSensitivity, Sensitivity) == 0x000000, "Member 'PhxGameUserSettings_SetAimSensitivity::Sensitivity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetAntiAliasingMethod
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetAntiAliasingMethod final
{
public:
	EAntiAliasingMethod                           InAntiAliasingMethod;                              // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetAntiAliasingMethod) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetAntiAliasingMethod");
static_assert(sizeof(PhxGameUserSettings_SetAntiAliasingMethod) == 0x000001, "Wrong size on PhxGameUserSettings_SetAntiAliasingMethod");
static_assert(offsetof(PhxGameUserSettings_SetAntiAliasingMethod, InAntiAliasingMethod) == 0x000000, "Member 'PhxGameUserSettings_SetAntiAliasingMethod::InAntiAliasingMethod' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetAutoAimEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetAutoAimEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetAutoAimEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetAutoAimEnabled");
static_assert(sizeof(PhxGameUserSettings_SetAutoAimEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetAutoAimEnabled");
static_assert(offsetof(PhxGameUserSettings_SetAutoAimEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetAutoAimEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetAutoDodgeEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetAutoDodgeEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetAutoDodgeEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetAutoDodgeEnabled");
static_assert(sizeof(PhxGameUserSettings_SetAutoDodgeEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetAutoDodgeEnabled");
static_assert(offsetof(PhxGameUserSettings_SetAutoDodgeEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetAutoDodgeEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetBenchmarkMode
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetBenchmarkMode final
{
public:
	bool                                          bValue;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetBenchmarkMode) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetBenchmarkMode");
static_assert(sizeof(PhxGameUserSettings_SetBenchmarkMode) == 0x000001, "Wrong size on PhxGameUserSettings_SetBenchmarkMode");
static_assert(offsetof(PhxGameUserSettings_SetBenchmarkMode, bValue) == 0x000000, "Member 'PhxGameUserSettings_SetBenchmarkMode::bValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetBlackPointValue
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetBlackPointValue final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetBlackPointValue) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetBlackPointValue");
static_assert(sizeof(PhxGameUserSettings_SetBlackPointValue) == 0x000004, "Wrong size on PhxGameUserSettings_SetBlackPointValue");
static_assert(offsetof(PhxGameUserSettings_SetBlackPointValue, InValue) == 0x000000, "Member 'PhxGameUserSettings_SetBlackPointValue::InValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetButtonHoldAssistEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetButtonHoldAssistEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetButtonHoldAssistEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetButtonHoldAssistEnabled");
static_assert(sizeof(PhxGameUserSettings_SetButtonHoldAssistEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetButtonHoldAssistEnabled");
static_assert(offsetof(PhxGameUserSettings_SetButtonHoldAssistEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetButtonHoldAssistEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetButtonPromptSize
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetButtonPromptSize final
{
public:
	ESDSSize                                      Size;                                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetButtonPromptSize) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetButtonPromptSize");
static_assert(sizeof(PhxGameUserSettings_SetButtonPromptSize) == 0x000001, "Wrong size on PhxGameUserSettings_SetButtonPromptSize");
static_assert(offsetof(PhxGameUserSettings_SetButtonPromptSize, Size) == 0x000000, "Member 'PhxGameUserSettings_SetButtonPromptSize::Size' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetCameraShakeIntensity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetCameraShakeIntensity final
{
public:
	float                                         Intensity;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetCameraShakeIntensity) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetCameraShakeIntensity");
static_assert(sizeof(PhxGameUserSettings_SetCameraShakeIntensity) == 0x000004, "Wrong size on PhxGameUserSettings_SetCameraShakeIntensity");
static_assert(offsetof(PhxGameUserSettings_SetCameraShakeIntensity, Intensity) == 0x000000, "Member 'PhxGameUserSettings_SetCameraShakeIntensity::Intensity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetCameraShakeReduceEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetCameraShakeReduceEnabled final
{
public:
	bool                                          bReduce;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetCameraShakeReduceEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetCameraShakeReduceEnabled");
static_assert(sizeof(PhxGameUserSettings_SetCameraShakeReduceEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetCameraShakeReduceEnabled");
static_assert(offsetof(PhxGameUserSettings_SetCameraShakeReduceEnabled, bReduce) == 0x000000, "Member 'PhxGameUserSettings_SetCameraShakeReduceEnabled::bReduce' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetCameraTwistIntensity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetCameraTwistIntensity final
{
public:
	float                                         Intensity;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetCameraTwistIntensity) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetCameraTwistIntensity");
static_assert(sizeof(PhxGameUserSettings_SetCameraTwistIntensity) == 0x000004, "Wrong size on PhxGameUserSettings_SetCameraTwistIntensity");
static_assert(offsetof(PhxGameUserSettings_SetCameraTwistIntensity, Intensity) == 0x000000, "Member 'PhxGameUserSettings_SetCameraTwistIntensity::Intensity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetCameraTwistReduceEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetCameraTwistReduceEnabled final
{
public:
	bool                                          bReduce;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetCameraTwistReduceEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetCameraTwistReduceEnabled");
static_assert(sizeof(PhxGameUserSettings_SetCameraTwistReduceEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetCameraTwistReduceEnabled");
static_assert(offsetof(PhxGameUserSettings_SetCameraTwistReduceEnabled, bReduce) == 0x000000, "Member 'PhxGameUserSettings_SetCameraTwistReduceEnabled::bReduce' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetControllerSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetControllerSensitivity final
{
public:
	float                                         Sensitivity;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetControllerSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetControllerSensitivity");
static_assert(sizeof(PhxGameUserSettings_SetControllerSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_SetControllerSensitivity");
static_assert(offsetof(PhxGameUserSettings_SetControllerSensitivity, Sensitivity) == 0x000000, "Member 'PhxGameUserSettings_SetControllerSensitivity::Sensitivity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDepthOfFieldEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetDepthOfFieldEnabled final
{
public:
	bool                                          bInDepthOfFieldEnabled;                            // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetDepthOfFieldEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetDepthOfFieldEnabled");
static_assert(sizeof(PhxGameUserSettings_SetDepthOfFieldEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetDepthOfFieldEnabled");
static_assert(offsetof(PhxGameUserSettings_SetDepthOfFieldEnabled, bInDepthOfFieldEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetDepthOfFieldEnabled::bInDepthOfFieldEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDialogCulture
// 0x0028 (0x0028 - 0x0000)
struct PhxGameUserSettings_SetDialogCulture final
{
public:
	class FString                                 CultureCode;                                       // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnFailure;                                         // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bAllowLanguagePackDownload;                        // 0x0020(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSetByUser;                                        // 0x0021(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_22[0x6];                                       // 0x0022(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameUserSettings_SetDialogCulture) == 0x000008, "Wrong alignment on PhxGameUserSettings_SetDialogCulture");
static_assert(sizeof(PhxGameUserSettings_SetDialogCulture) == 0x000028, "Wrong size on PhxGameUserSettings_SetDialogCulture");
static_assert(offsetof(PhxGameUserSettings_SetDialogCulture, CultureCode) == 0x000000, "Member 'PhxGameUserSettings_SetDialogCulture::CultureCode' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_SetDialogCulture, OnFailure) == 0x000010, "Member 'PhxGameUserSettings_SetDialogCulture::OnFailure' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_SetDialogCulture, bAllowLanguagePackDownload) == 0x000020, "Member 'PhxGameUserSettings_SetDialogCulture::bAllowLanguagePackDownload' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_SetDialogCulture, bSetByUser) == 0x000021, "Member 'PhxGameUserSettings_SetDialogCulture::bSetByUser' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDialogueEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetDialogueEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetDialogueEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetDialogueEnabled");
static_assert(sizeof(PhxGameUserSettings_SetDialogueEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetDialogueEnabled");
static_assert(offsetof(PhxGameUserSettings_SetDialogueEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetDialogueEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDialogueVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetDialogueVolume final
{
public:
	float                                         Volume;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetDialogueVolume) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetDialogueVolume");
static_assert(sizeof(PhxGameUserSettings_SetDialogueVolume) == 0x000004, "Wrong size on PhxGameUserSettings_SetDialogueVolume");
static_assert(offsetof(PhxGameUserSettings_SetDialogueVolume, Volume) == 0x000000, "Member 'PhxGameUserSettings_SetDialogueVolume::Volume' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDirectXRHI
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetDirectXRHI final
{
public:
	EDirectXRHI                                   InDirectXRHI;                                      // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetDirectXRHI) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetDirectXRHI");
static_assert(sizeof(PhxGameUserSettings_SetDirectXRHI) == 0x000001, "Wrong size on PhxGameUserSettings_SetDirectXRHI");
static_assert(offsetof(PhxGameUserSettings_SetDirectXRHI, InDirectXRHI) == 0x000000, "Member 'PhxGameUserSettings_SetDirectXRHI::InDirectXRHI' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDismembermentUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetDismembermentUnlockDisplayed final
{
public:
	bool                                          bInIsDisplayed;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetDismembermentUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetDismembermentUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_SetDismembermentUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_SetDismembermentUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_SetDismembermentUnlockDisplayed, bInIsDisplayed) == 0x000000, "Member 'PhxGameUserSettings_SetDismembermentUnlockDisplayed::bInIsDisplayed' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDisplayType
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetDisplayType final
{
public:
	EPhxDisplayType                               InDisplayType;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetDisplayType) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetDisplayType");
static_assert(sizeof(PhxGameUserSettings_SetDisplayType) == 0x000001, "Wrong size on PhxGameUserSettings_SetDisplayType");
static_assert(offsetof(PhxGameUserSettings_SetDisplayType, InDisplayType) == 0x000000, "Member 'PhxGameUserSettings_SetDisplayType::InDisplayType' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDLCNotificationIcon
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetDLCNotificationIcon final
{
public:
	bool                                          bIsOn;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetDLCNotificationIcon) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetDLCNotificationIcon");
static_assert(sizeof(PhxGameUserSettings_SetDLCNotificationIcon) == 0x000001, "Wrong size on PhxGameUserSettings_SetDLCNotificationIcon");
static_assert(offsetof(PhxGameUserSettings_SetDLCNotificationIcon, bIsOn) == 0x000000, "Member 'PhxGameUserSettings_SetDLCNotificationIcon::bIsOn' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDLCStoreUnlockID
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetDLCStoreUnlockID final
{
public:
	int32                                         VersionID;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetDLCStoreUnlockID) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetDLCStoreUnlockID");
static_assert(sizeof(PhxGameUserSettings_SetDLCStoreUnlockID) == 0x000004, "Wrong size on PhxGameUserSettings_SetDLCStoreUnlockID");
static_assert(offsetof(PhxGameUserSettings_SetDLCStoreUnlockID, VersionID) == 0x000000, "Member 'PhxGameUserSettings_SetDLCStoreUnlockID::VersionID' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetDyslexicFontEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetDyslexicFontEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetDyslexicFontEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetDyslexicFontEnabled");
static_assert(sizeof(PhxGameUserSettings_SetDyslexicFontEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetDyslexicFontEnabled");
static_assert(offsetof(PhxGameUserSettings_SetDyslexicFontEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetDyslexicFontEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetFilmGrainEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetFilmGrainEnabled final
{
public:
	bool                                          bInFilmGrainEnabled;                               // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetFilmGrainEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetFilmGrainEnabled");
static_assert(sizeof(PhxGameUserSettings_SetFilmGrainEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetFilmGrainEnabled");
static_assert(offsetof(PhxGameUserSettings_SetFilmGrainEnabled, bInFilmGrainEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetFilmGrainEnabled::bInFilmGrainEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetFirstOnlineRun
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetFirstOnlineRun final
{
public:
	bool                                          bInFirstOnlineRun;                                 // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetFirstOnlineRun) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetFirstOnlineRun");
static_assert(sizeof(PhxGameUserSettings_SetFirstOnlineRun) == 0x000001, "Wrong size on PhxGameUserSettings_SetFirstOnlineRun");
static_assert(offsetof(PhxGameUserSettings_SetFirstOnlineRun, bInFirstOnlineRun) == 0x000000, "Member 'PhxGameUserSettings_SetFirstOnlineRun::bInFirstOnlineRun' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetFirstRun
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetFirstRun final
{
public:
	bool                                          bInFirstRun;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetFirstRun) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetFirstRun");
static_assert(sizeof(PhxGameUserSettings_SetFirstRun) == 0x000001, "Wrong size on PhxGameUserSettings_SetFirstRun");
static_assert(offsetof(PhxGameUserSettings_SetFirstRun, bInFirstRun) == 0x000000, "Member 'PhxGameUserSettings_SetFirstRun::bInFirstRun' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetFSR2Mode
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetFSR2Mode final
{
public:
	EFSR2QualityModeWrapper                       bInFSR2Mode;                                       // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetFSR2Mode) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetFSR2Mode");
static_assert(sizeof(PhxGameUserSettings_SetFSR2Mode) == 0x000001, "Wrong size on PhxGameUserSettings_SetFSR2Mode");
static_assert(offsetof(PhxGameUserSettings_SetFSR2Mode, bInFSR2Mode) == 0x000000, "Member 'PhxGameUserSettings_SetFSR2Mode::bInFSR2Mode' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetGameDifficultyLevel
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetGameDifficultyLevel final
{
public:
	EPhxDifficultyLevel                           Level;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetGameDifficultyLevel) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetGameDifficultyLevel");
static_assert(sizeof(PhxGameUserSettings_SetGameDifficultyLevel) == 0x000001, "Wrong size on PhxGameUserSettings_SetGameDifficultyLevel");
static_assert(offsetof(PhxGameUserSettings_SetGameDifficultyLevel, Level) == 0x000000, "Member 'PhxGameUserSettings_SetGameDifficultyLevel::Level' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetGoldSkinUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetGoldSkinUnlockDisplayed final
{
public:
	bool                                          bInIsDisplayed;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetGoldSkinUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetGoldSkinUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_SetGoldSkinUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_SetGoldSkinUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_SetGoldSkinUnlockDisplayed, bInIsDisplayed) == 0x000000, "Member 'PhxGameUserSettings_SetGoldSkinUnlockDisplayed::bInIsDisplayed' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetGoreEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetGoreEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetGoreEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetGoreEnabled");
static_assert(sizeof(PhxGameUserSettings_SetGoreEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetGoreEnabled");
static_assert(offsetof(PhxGameUserSettings_SetGoreEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetGoreEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetGraphicsPreset
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetGraphicsPreset final
{
public:
	EPhxGraphicsPreset                            PresetLevel;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetGraphicsPreset) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetGraphicsPreset");
static_assert(sizeof(PhxGameUserSettings_SetGraphicsPreset) == 0x000001, "Wrong size on PhxGameUserSettings_SetGraphicsPreset");
static_assert(offsetof(PhxGameUserSettings_SetGraphicsPreset, PresetLevel) == 0x000000, "Member 'PhxGameUserSettings_SetGraphicsPreset::PresetLevel' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetGyroAimEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetGyroAimEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetGyroAimEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetGyroAimEnabled");
static_assert(sizeof(PhxGameUserSettings_SetGyroAimEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetGyroAimEnabled");
static_assert(offsetof(PhxGameUserSettings_SetGyroAimEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetGyroAimEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetGyroAimSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetGyroAimSensitivity final
{
public:
	float                                         Sensitivity;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetGyroAimSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetGyroAimSensitivity");
static_assert(sizeof(PhxGameUserSettings_SetGyroAimSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_SetGyroAimSensitivity");
static_assert(offsetof(PhxGameUserSettings_SetGyroAimSensitivity, Sensitivity) == 0x000000, "Member 'PhxGameUserSettings_SetGyroAimSensitivity::Sensitivity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHallucinationFXEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetHallucinationFXEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHallucinationFXEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetHallucinationFXEnabled");
static_assert(sizeof(PhxGameUserSettings_SetHallucinationFXEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetHallucinationFXEnabled");
static_assert(offsetof(PhxGameUserSettings_SetHallucinationFXEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetHallucinationFXEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHardcoreNGPlusUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetHardcoreNGPlusUnlockDisplayed final
{
public:
	bool                                          bInIsDisplayed;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHardcoreNGPlusUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetHardcoreNGPlusUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_SetHardcoreNGPlusUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_SetHardcoreNGPlusUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_SetHardcoreNGPlusUnlockDisplayed, bInIsDisplayed) == 0x000000, "Member 'PhxGameUserSettings_SetHardcoreNGPlusUnlockDisplayed::bInIsDisplayed' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHardcoreUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetHardcoreUnlockDisplayed final
{
public:
	bool                                          bInIsDisplayed;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHardcoreUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetHardcoreUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_SetHardcoreUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_SetHardcoreUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_SetHardcoreUnlockDisplayed, bInIsDisplayed) == 0x000000, "Member 'PhxGameUserSettings_SetHardcoreUnlockDisplayed::bInIsDisplayed' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHasShownNewGamePlusNotification
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetHasShownNewGamePlusNotification final
{
public:
	bool                                          bNewHasShownNewGamePlusNotification;               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHasShownNewGamePlusNotification) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetHasShownNewGamePlusNotification");
static_assert(sizeof(PhxGameUserSettings_SetHasShownNewGamePlusNotification) == 0x000001, "Wrong size on PhxGameUserSettings_SetHasShownNewGamePlusNotification");
static_assert(offsetof(PhxGameUserSettings_SetHasShownNewGamePlusNotification, bNewHasShownNewGamePlusNotification) == 0x000000, "Member 'PhxGameUserSettings_SetHasShownNewGamePlusNotification::bNewHasShownNewGamePlusNotification' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHazmatUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetHazmatUnlockDisplayed final
{
public:
	bool                                          bInIsDisplayed;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHazmatUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetHazmatUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_SetHazmatUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_SetHazmatUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_SetHazmatUnlockDisplayed, bInIsDisplayed) == 0x000000, "Member 'PhxGameUserSettings_SetHazmatUnlockDisplayed::bInIsDisplayed' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHCEnemyColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_SetHCEnemyColor final
{
public:
	struct FLinearColor                           InColor;                                           // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHCEnemyColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetHCEnemyColor");
static_assert(sizeof(PhxGameUserSettings_SetHCEnemyColor) == 0x000010, "Wrong size on PhxGameUserSettings_SetHCEnemyColor");
static_assert(offsetof(PhxGameUserSettings_SetHCEnemyColor, InColor) == 0x000000, "Member 'PhxGameUserSettings_SetHCEnemyColor::InColor' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHCHazardColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_SetHCHazardColor final
{
public:
	struct FLinearColor                           InColor;                                           // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHCHazardColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetHCHazardColor");
static_assert(sizeof(PhxGameUserSettings_SetHCHazardColor) == 0x000010, "Wrong size on PhxGameUserSettings_SetHCHazardColor");
static_assert(offsetof(PhxGameUserSettings_SetHCHazardColor, InColor) == 0x000000, "Member 'PhxGameUserSettings_SetHCHazardColor::InColor' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHCPickupColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_SetHCPickupColor final
{
public:
	struct FLinearColor                           InColor;                                           // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHCPickupColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetHCPickupColor");
static_assert(sizeof(PhxGameUserSettings_SetHCPickupColor) == 0x000010, "Wrong size on PhxGameUserSettings_SetHCPickupColor");
static_assert(offsetof(PhxGameUserSettings_SetHCPickupColor, InColor) == 0x000000, "Member 'PhxGameUserSettings_SetHCPickupColor::InColor' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHCPlayerColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_SetHCPlayerColor final
{
public:
	struct FLinearColor                           InColor;                                           // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHCPlayerColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetHCPlayerColor");
static_assert(sizeof(PhxGameUserSettings_SetHCPlayerColor) == 0x000010, "Wrong size on PhxGameUserSettings_SetHCPlayerColor");
static_assert(offsetof(PhxGameUserSettings_SetHCPlayerColor, InColor) == 0x000000, "Member 'PhxGameUserSettings_SetHCPlayerColor::InColor' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHDRBlackPointCorrectionValue
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetHDRBlackPointCorrectionValue final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHDRBlackPointCorrectionValue) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetHDRBlackPointCorrectionValue");
static_assert(sizeof(PhxGameUserSettings_SetHDRBlackPointCorrectionValue) == 0x000004, "Wrong size on PhxGameUserSettings_SetHDRBlackPointCorrectionValue");
static_assert(offsetof(PhxGameUserSettings_SetHDRBlackPointCorrectionValue, InValue) == 0x000000, "Member 'PhxGameUserSettings_SetHDRBlackPointCorrectionValue::InValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHDRBrightnessValue
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetHDRBrightnessValue final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHDRBrightnessValue) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetHDRBrightnessValue");
static_assert(sizeof(PhxGameUserSettings_SetHDRBrightnessValue) == 0x000004, "Wrong size on PhxGameUserSettings_SetHDRBrightnessValue");
static_assert(offsetof(PhxGameUserSettings_SetHDRBrightnessValue, InValue) == 0x000000, "Member 'PhxGameUserSettings_SetHDRBrightnessValue::InValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHideBrightnessFlow
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetHideBrightnessFlow final
{
public:
	bool                                          bHide;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHideBrightnessFlow) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetHideBrightnessFlow");
static_assert(sizeof(PhxGameUserSettings_SetHideBrightnessFlow) == 0x000001, "Wrong size on PhxGameUserSettings_SetHideBrightnessFlow");
static_assert(offsetof(PhxGameUserSettings_SetHideBrightnessFlow, bHide) == 0x000000, "Member 'PhxGameUserSettings_SetHideBrightnessFlow::bHide' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHighContrastEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetHighContrastEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHighContrastEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetHighContrastEnabled");
static_assert(sizeof(PhxGameUserSettings_SetHighContrastEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetHighContrastEnabled");
static_assert(offsetof(PhxGameUserSettings_SetHighContrastEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetHighContrastEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetHordeUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetHordeUnlockDisplayed final
{
public:
	bool                                          bInIsDisplayed;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetHordeUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetHordeUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_SetHordeUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_SetHordeUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_SetHordeUnlockDisplayed, bInIsDisplayed) == 0x000000, "Member 'PhxGameUserSettings_SetHordeUnlockDisplayed::bInIsDisplayed' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetInputMappingSettings
// 0x0028 (0x0028 - 0x0000)
struct PhxGameUserSettings_SetInputMappingSettings final
{
public:
	TSoftObjectPtr<class UPhxInputMappingSettings> InputMappingSettingsAsset;                        // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetInputMappingSettings) == 0x000008, "Wrong alignment on PhxGameUserSettings_SetInputMappingSettings");
static_assert(sizeof(PhxGameUserSettings_SetInputMappingSettings) == 0x000028, "Wrong size on PhxGameUserSettings_SetInputMappingSettings");
static_assert(offsetof(PhxGameUserSettings_SetInputMappingSettings, InputMappingSettingsAsset) == 0x000000, "Member 'PhxGameUserSettings_SetInputMappingSettings::InputMappingSettingsAsset' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetInventoryParallaxEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetInventoryParallaxEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetInventoryParallaxEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetInventoryParallaxEnabled");
static_assert(sizeof(PhxGameUserSettings_SetInventoryParallaxEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetInventoryParallaxEnabled");
static_assert(offsetof(PhxGameUserSettings_SetInventoryParallaxEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetInventoryParallaxEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetInvertMouseX
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetInvertMouseX final
{
public:
	bool                                          bInvert;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetInvertMouseX) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetInvertMouseX");
static_assert(sizeof(PhxGameUserSettings_SetInvertMouseX) == 0x000001, "Wrong size on PhxGameUserSettings_SetInvertMouseX");
static_assert(offsetof(PhxGameUserSettings_SetInvertMouseX, bInvert) == 0x000000, "Member 'PhxGameUserSettings_SetInvertMouseX::bInvert' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetInvertMouseY
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetInvertMouseY final
{
public:
	bool                                          bInvert;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetInvertMouseY) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetInvertMouseY");
static_assert(sizeof(PhxGameUserSettings_SetInvertMouseY) == 0x000001, "Wrong size on PhxGameUserSettings_SetInvertMouseY");
static_assert(offsetof(PhxGameUserSettings_SetInvertMouseY, bInvert) == 0x000000, "Member 'PhxGameUserSettings_SetInvertMouseY::bInvert' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetInvertX
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetInvertX final
{
public:
	bool                                          bInvert;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetInvertX) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetInvertX");
static_assert(sizeof(PhxGameUserSettings_SetInvertX) == 0x000001, "Wrong size on PhxGameUserSettings_SetInvertX");
static_assert(offsetof(PhxGameUserSettings_SetInvertX, bInvert) == 0x000000, "Member 'PhxGameUserSettings_SetInvertX::bInvert' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetInvertY
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetInvertY final
{
public:
	bool                                          bInvert;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetInvertY) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetInvertY");
static_assert(sizeof(PhxGameUserSettings_SetInvertY) == 0x000001, "Wrong size on PhxGameUserSettings_SetInvertY");
static_assert(offsetof(PhxGameUserSettings_SetInvertY, bInvert) == 0x000000, "Member 'PhxGameUserSettings_SetInvertY::bInvert' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetKeyMapping
// 0x0020 (0x0020 - 0x0000)
struct PhxGameUserSettings_SetKeyMapping final
{
public:
	TArray<struct FPhxInputActionMappingSetting>  ActionList;                                        // 0x0000(0x0010)(Parm, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FPhxInputAxisMappingSetting>    AxisList;                                          // 0x0010(0x0010)(Parm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetKeyMapping) == 0x000008, "Wrong alignment on PhxGameUserSettings_SetKeyMapping");
static_assert(sizeof(PhxGameUserSettings_SetKeyMapping) == 0x000020, "Wrong size on PhxGameUserSettings_SetKeyMapping");
static_assert(offsetof(PhxGameUserSettings_SetKeyMapping, ActionList) == 0x000000, "Member 'PhxGameUserSettings_SetKeyMapping::ActionList' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_SetKeyMapping, AxisList) == 0x000010, "Member 'PhxGameUserSettings_SetKeyMapping::AxisList' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetLefthandBiasedInput
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetLefthandBiasedInput final
{
public:
	bool                                          bUseLeftBiasedInput;                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetLefthandBiasedInput) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetLefthandBiasedInput");
static_assert(sizeof(PhxGameUserSettings_SetLefthandBiasedInput) == 0x000001, "Wrong size on PhxGameUserSettings_SetLefthandBiasedInput");
static_assert(offsetof(PhxGameUserSettings_SetLefthandBiasedInput, bUseLeftBiasedInput) == 0x000000, "Member 'PhxGameUserSettings_SetLefthandBiasedInput::bUseLeftBiasedInput' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetLightingQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetLightingQuality final
{
public:
	EGraphicsQuality                              InLightingQuality;                                 // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetLightingQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetLightingQuality");
static_assert(sizeof(PhxGameUserSettings_SetLightingQuality) == 0x000001, "Wrong size on PhxGameUserSettings_SetLightingQuality");
static_assert(offsetof(PhxGameUserSettings_SetLightingQuality, InLightingQuality) == 0x000000, "Member 'PhxGameUserSettings_SetLightingQuality::InLightingQuality' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetLookSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetLookSensitivity final
{
public:
	float                                         Sensitivity;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetLookSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetLookSensitivity");
static_assert(sizeof(PhxGameUserSettings_SetLookSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_SetLookSensitivity");
static_assert(offsetof(PhxGameUserSettings_SetLookSensitivity, Sensitivity) == 0x000000, "Member 'PhxGameUserSettings_SetLookSensitivity::Sensitivity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetLowHealthFXEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetLowHealthFXEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetLowHealthFXEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetLowHealthFXEnabled");
static_assert(sizeof(PhxGameUserSettings_SetLowHealthFXEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetLowHealthFXEnabled");
static_assert(offsetof(PhxGameUserSettings_SetLowHealthFXEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetLowHealthFXEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMeleeHoldEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetMeleeHoldEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMeleeHoldEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetMeleeHoldEnabled");
static_assert(sizeof(PhxGameUserSettings_SetMeleeHoldEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetMeleeHoldEnabled");
static_assert(offsetof(PhxGameUserSettings_SetMeleeHoldEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetMeleeHoldEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMenuReaderEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetMenuReaderEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMenuReaderEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetMenuReaderEnabled");
static_assert(sizeof(PhxGameUserSettings_SetMenuReaderEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetMenuReaderEnabled");
static_assert(offsetof(PhxGameUserSettings_SetMenuReaderEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetMenuReaderEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMeshQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetMeshQuality final
{
public:
	EGraphicsQuality                              InMeshQuality;                                     // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMeshQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetMeshQuality");
static_assert(sizeof(PhxGameUserSettings_SetMeshQuality) == 0x000001, "Wrong size on PhxGameUserSettings_SetMeshQuality");
static_assert(offsetof(PhxGameUserSettings_SetMeshQuality, InMeshQuality) == 0x000000, "Member 'PhxGameUserSettings_SetMeshQuality::InMeshQuality' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMotionBlurEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetMotionBlurEnabled final
{
public:
	bool                                          bInMotionBlurEnabled;                              // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMotionBlurEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetMotionBlurEnabled");
static_assert(sizeof(PhxGameUserSettings_SetMotionBlurEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetMotionBlurEnabled");
static_assert(offsetof(PhxGameUserSettings_SetMotionBlurEnabled, bInMotionBlurEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetMotionBlurEnabled::bInMotionBlurEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMouseAimSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetMouseAimSensitivity final
{
public:
	float                                         Sensitivity;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMouseAimSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetMouseAimSensitivity");
static_assert(sizeof(PhxGameUserSettings_SetMouseAimSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_SetMouseAimSensitivity");
static_assert(offsetof(PhxGameUserSettings_SetMouseAimSensitivity, Sensitivity) == 0x000000, "Member 'PhxGameUserSettings_SetMouseAimSensitivity::Sensitivity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMouseAimSmoothing
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetMouseAimSmoothing final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMouseAimSmoothing) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetMouseAimSmoothing");
static_assert(sizeof(PhxGameUserSettings_SetMouseAimSmoothing) == 0x000001, "Wrong size on PhxGameUserSettings_SetMouseAimSmoothing");
static_assert(offsetof(PhxGameUserSettings_SetMouseAimSmoothing, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetMouseAimSmoothing::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMouseLookSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetMouseLookSensitivity final
{
public:
	float                                         Sensitivity;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMouseLookSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetMouseLookSensitivity");
static_assert(sizeof(PhxGameUserSettings_SetMouseLookSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_SetMouseLookSensitivity");
static_assert(offsetof(PhxGameUserSettings_SetMouseLookSensitivity, Sensitivity) == 0x000000, "Member 'PhxGameUserSettings_SetMouseLookSensitivity::Sensitivity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMouseLookSmoothing
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetMouseLookSmoothing final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMouseLookSmoothing) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetMouseLookSmoothing");
static_assert(sizeof(PhxGameUserSettings_SetMouseLookSmoothing) == 0x000001, "Wrong size on PhxGameUserSettings_SetMouseLookSmoothing");
static_assert(offsetof(PhxGameUserSettings_SetMouseLookSmoothing, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetMouseLookSmoothing::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMusicEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetMusicEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMusicEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetMusicEnabled");
static_assert(sizeof(PhxGameUserSettings_SetMusicEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetMusicEnabled");
static_assert(offsetof(PhxGameUserSettings_SetMusicEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetMusicEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetMusicVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetMusicVolume final
{
public:
	float                                         Intensity;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetMusicVolume) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetMusicVolume");
static_assert(sizeof(PhxGameUserSettings_SetMusicVolume) == 0x000004, "Wrong size on PhxGameUserSettings_SetMusicVolume");
static_assert(offsetof(PhxGameUserSettings_SetMusicVolume, Intensity) == 0x000000, "Member 'PhxGameUserSettings_SetMusicVolume::Intensity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetParticleQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetParticleQuality final
{
public:
	EGraphicsQuality                              InParticleQuality;                                 // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetParticleQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetParticleQuality");
static_assert(sizeof(PhxGameUserSettings_SetParticleQuality) == 0x000001, "Wrong size on PhxGameUserSettings_SetParticleQuality");
static_assert(offsetof(PhxGameUserSettings_SetParticleQuality, InParticleQuality) == 0x000000, "Member 'PhxGameUserSettings_SetParticleQuality::InParticleQuality' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetPhysicalRefractionEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetPhysicalRefractionEnabled final
{
public:
	bool                                          bInPhysicalRefractionEnabled;                      // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetPhysicalRefractionEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetPhysicalRefractionEnabled");
static_assert(sizeof(PhxGameUserSettings_SetPhysicalRefractionEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetPhysicalRefractionEnabled");
static_assert(offsetof(PhxGameUserSettings_SetPhysicalRefractionEnabled, bInPhysicalRefractionEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetPhysicalRefractionEnabled::bInPhysicalRefractionEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetQTEAutoCompleteEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetQTEAutoCompleteEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetQTEAutoCompleteEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetQTEAutoCompleteEnabled");
static_assert(sizeof(PhxGameUserSettings_SetQTEAutoCompleteEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetQTEAutoCompleteEnabled");
static_assert(offsetof(PhxGameUserSettings_SetQTEAutoCompleteEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetQTEAutoCompleteEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetQTESinglePressEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetQTESinglePressEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetQTESinglePressEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetQTESinglePressEnabled");
static_assert(sizeof(PhxGameUserSettings_SetQTESinglePressEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetQTESinglePressEnabled");
static_assert(offsetof(PhxGameUserSettings_SetQTESinglePressEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetQTESinglePressEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetRadioBanterChannel
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetRadioBanterChannel final
{
public:
	EPhxRadioBanterChannel                        Channel;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetRadioBanterChannel) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetRadioBanterChannel");
static_assert(sizeof(PhxGameUserSettings_SetRadioBanterChannel) == 0x000001, "Wrong size on PhxGameUserSettings_SetRadioBanterChannel");
static_assert(offsetof(PhxGameUserSettings_SetRadioBanterChannel, Channel) == 0x000000, "Member 'PhxGameUserSettings_SetRadioBanterChannel::Channel' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetRadioBanterVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetRadioBanterVolume final
{
public:
	float                                         Volume;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetRadioBanterVolume) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetRadioBanterVolume");
static_assert(sizeof(PhxGameUserSettings_SetRadioBanterVolume) == 0x000004, "Wrong size on PhxGameUserSettings_SetRadioBanterVolume");
static_assert(offsetof(PhxGameUserSettings_SetRadioBanterVolume, Volume) == 0x000000, "Member 'PhxGameUserSettings_SetRadioBanterVolume::Volume' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetRaytracedReflectionsQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetRaytracedReflectionsQuality final
{
public:
	EGraphicsQuality                              InRaytracedReflectionsQuality;                     // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetRaytracedReflectionsQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetRaytracedReflectionsQuality");
static_assert(sizeof(PhxGameUserSettings_SetRaytracedReflectionsQuality) == 0x000001, "Wrong size on PhxGameUserSettings_SetRaytracedReflectionsQuality");
static_assert(offsetof(PhxGameUserSettings_SetRaytracedReflectionsQuality, InRaytracedReflectionsQuality) == 0x000000, "Member 'PhxGameUserSettings_SetRaytracedReflectionsQuality::InRaytracedReflectionsQuality' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetRaytracedShadowsEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetRaytracedShadowsEnabled final
{
public:
	bool                                          bInRaytracedShadowsEnabled;                        // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetRaytracedShadowsEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetRaytracedShadowsEnabled");
static_assert(sizeof(PhxGameUserSettings_SetRaytracedShadowsEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetRaytracedShadowsEnabled");
static_assert(offsetof(PhxGameUserSettings_SetRaytracedShadowsEnabled, bInRaytracedShadowsEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetRaytracedShadowsEnabled::bInRaytracedShadowsEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetRaytracedTransmissionEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetRaytracedTransmissionEnabled final
{
public:
	bool                                          bInRaytracedTransmissionEnabled;                   // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetRaytracedTransmissionEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetRaytracedTransmissionEnabled");
static_assert(sizeof(PhxGameUserSettings_SetRaytracedTransmissionEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetRaytracedTransmissionEnabled");
static_assert(offsetof(PhxGameUserSettings_SetRaytracedTransmissionEnabled, bInRaytracedTransmissionEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetRaytracedTransmissionEnabled::bInRaytracedTransmissionEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetRenderResolutionPercentage
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetRenderResolutionPercentage final
{
public:
	float                                         InRenderResolutionPercentage;                      // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetRenderResolutionPercentage) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetRenderResolutionPercentage");
static_assert(sizeof(PhxGameUserSettings_SetRenderResolutionPercentage) == 0x000004, "Wrong size on PhxGameUserSettings_SetRenderResolutionPercentage");
static_assert(offsetof(PhxGameUserSettings_SetRenderResolutionPercentage, InRenderResolutionPercentage) == 0x000000, "Member 'PhxGameUserSettings_SetRenderResolutionPercentage::InRenderResolutionPercentage' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetRumbleEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetRumbleEnabled final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetRumbleEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetRumbleEnabled");
static_assert(sizeof(PhxGameUserSettings_SetRumbleEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetRumbleEnabled");
static_assert(offsetof(PhxGameUserSettings_SetRumbleEnabled, bEnable) == 0x000000, "Member 'PhxGameUserSettings_SetRumbleEnabled::bEnable' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetScreenSpaceReflectionsEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetScreenSpaceReflectionsEnabled final
{
public:
	bool                                          bInScreenSpaceReflectionsEnabled;                  // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetScreenSpaceReflectionsEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetScreenSpaceReflectionsEnabled");
static_assert(sizeof(PhxGameUserSettings_SetScreenSpaceReflectionsEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetScreenSpaceReflectionsEnabled");
static_assert(offsetof(PhxGameUserSettings_SetScreenSpaceReflectionsEnabled, bInScreenSpaceReflectionsEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetScreenSpaceReflectionsEnabled::bInScreenSpaceReflectionsEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSeenMenuReaderPrompt
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetSeenMenuReaderPrompt final
{
public:
	bool                                          bSeenPrompt;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSeenMenuReaderPrompt) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetSeenMenuReaderPrompt");
static_assert(sizeof(PhxGameUserSettings_SetSeenMenuReaderPrompt) == 0x000001, "Wrong size on PhxGameUserSettings_SetSeenMenuReaderPrompt");
static_assert(offsetof(PhxGameUserSettings_SetSeenMenuReaderPrompt, bSeenPrompt) == 0x000000, "Member 'PhxGameUserSettings_SetSeenMenuReaderPrompt::bSeenPrompt' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSFXEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetSFXEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSFXEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetSFXEnabled");
static_assert(sizeof(PhxGameUserSettings_SetSFXEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetSFXEnabled");
static_assert(offsetof(PhxGameUserSettings_SetSFXEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetSFXEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSFXVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetSFXVolume final
{
public:
	float                                         Intensity;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSFXVolume) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetSFXVolume");
static_assert(sizeof(PhxGameUserSettings_SetSFXVolume) == 0x000004, "Wrong size on PhxGameUserSettings_SetSFXVolume");
static_assert(offsetof(PhxGameUserSettings_SetSFXVolume, Intensity) == 0x000000, "Member 'PhxGameUserSettings_SetSFXVolume::Intensity' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetShadowMapQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetShadowMapQuality final
{
public:
	EGraphicsQuality                              InShadowMapQuality;                                // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetShadowMapQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetShadowMapQuality");
static_assert(sizeof(PhxGameUserSettings_SetShadowMapQuality) == 0x000001, "Wrong size on PhxGameUserSettings_SetShadowMapQuality");
static_assert(offsetof(PhxGameUserSettings_SetShadowMapQuality, InShadowMapQuality) == 0x000000, "Member 'PhxGameUserSettings_SetShadowMapQuality::InShadowMapQuality' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetShowRiotModeRules
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetShowRiotModeRules final
{
public:
	bool                                          bShowRules;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetShowRiotModeRules) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetShowRiotModeRules");
static_assert(sizeof(PhxGameUserSettings_SetShowRiotModeRules) == 0x000001, "Wrong size on PhxGameUserSettings_SetShowRiotModeRules");
static_assert(offsetof(PhxGameUserSettings_SetShowRiotModeRules, bShowRules) == 0x000000, "Member 'PhxGameUserSettings_SetShowRiotModeRules::bShowRules' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetStoryDLCUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetStoryDLCUnlockDisplayed final
{
public:
	bool                                          bInIsDisplayed;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetStoryDLCUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetStoryDLCUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_SetStoryDLCUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_SetStoryDLCUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_SetStoryDLCUnlockDisplayed, bInIsDisplayed) == 0x000000, "Member 'PhxGameUserSettings_SetStoryDLCUnlockDisplayed::bInIsDisplayed' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsBGColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_SetSubsBGColor final
{
public:
	struct FLinearColor                           InValue;                                           // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSubsBGColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetSubsBGColor");
static_assert(sizeof(PhxGameUserSettings_SetSubsBGColor) == 0x000010, "Wrong size on PhxGameUserSettings_SetSubsBGColor");
static_assert(offsetof(PhxGameUserSettings_SetSubsBGColor, InValue) == 0x000000, "Member 'PhxGameUserSettings_SetSubsBGColor::InValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsBGEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetSubsBGEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSubsBGEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetSubsBGEnabled");
static_assert(sizeof(PhxGameUserSettings_SetSubsBGEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetSubsBGEnabled");
static_assert(offsetof(PhxGameUserSettings_SetSubsBGEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetSubsBGEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsBGOpacity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetSubsBGOpacity final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSubsBGOpacity) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetSubsBGOpacity");
static_assert(sizeof(PhxGameUserSettings_SetSubsBGOpacity) == 0x000004, "Wrong size on PhxGameUserSettings_SetSubsBGOpacity");
static_assert(offsetof(PhxGameUserSettings_SetSubsBGOpacity, InValue) == 0x000000, "Member 'PhxGameUserSettings_SetSubsBGOpacity::InValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsCulture
// 0x0018 (0x0018 - 0x0000)
struct PhxGameUserSettings_SetSubsCulture final
{
public:
	class FString                                 CultureCode;                                       // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSetByUser;                                        // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameUserSettings_SetSubsCulture) == 0x000008, "Wrong alignment on PhxGameUserSettings_SetSubsCulture");
static_assert(sizeof(PhxGameUserSettings_SetSubsCulture) == 0x000018, "Wrong size on PhxGameUserSettings_SetSubsCulture");
static_assert(offsetof(PhxGameUserSettings_SetSubsCulture, CultureCode) == 0x000000, "Member 'PhxGameUserSettings_SetSubsCulture::CultureCode' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_SetSubsCulture, bSetByUser) == 0x000010, "Member 'PhxGameUserSettings_SetSubsCulture::bSetByUser' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetSubsEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSubsEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetSubsEnabled");
static_assert(sizeof(PhxGameUserSettings_SetSubsEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetSubsEnabled");
static_assert(offsetof(PhxGameUserSettings_SetSubsEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetSubsEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsFontColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_SetSubsFontColor final
{
public:
	struct FLinearColor                           InValue;                                           // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSubsFontColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetSubsFontColor");
static_assert(sizeof(PhxGameUserSettings_SetSubsFontColor) == 0x000010, "Wrong size on PhxGameUserSettings_SetSubsFontColor");
static_assert(offsetof(PhxGameUserSettings_SetSubsFontColor, InValue) == 0x000000, "Member 'PhxGameUserSettings_SetSubsFontColor::InValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsFontScale
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetSubsFontScale final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSubsFontScale) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetSubsFontScale");
static_assert(sizeof(PhxGameUserSettings_SetSubsFontScale) == 0x000004, "Wrong size on PhxGameUserSettings_SetSubsFontScale");
static_assert(offsetof(PhxGameUserSettings_SetSubsFontScale, InValue) == 0x000000, "Member 'PhxGameUserSettings_SetSubsFontScale::InValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsSpeakerColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_SetSubsSpeakerColor final
{
public:
	struct FLinearColor                           InValue;                                           // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSubsSpeakerColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetSubsSpeakerColor");
static_assert(sizeof(PhxGameUserSettings_SetSubsSpeakerColor) == 0x000010, "Wrong size on PhxGameUserSettings_SetSubsSpeakerColor");
static_assert(offsetof(PhxGameUserSettings_SetSubsSpeakerColor, InValue) == 0x000000, "Member 'PhxGameUserSettings_SetSubsSpeakerColor::InValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsSpeakerEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetSubsSpeakerEnabled final
{
public:
	bool                                          bEnabled;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSubsSpeakerEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetSubsSpeakerEnabled");
static_assert(sizeof(PhxGameUserSettings_SetSubsSpeakerEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetSubsSpeakerEnabled");
static_assert(offsetof(PhxGameUserSettings_SetSubsSpeakerEnabled, bEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetSubsSpeakerEnabled::bEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSubsurfaceScatteringEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetSubsurfaceScatteringEnabled final
{
public:
	bool                                          bInSubsurfaceScatteringEnabled;                    // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSubsurfaceScatteringEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetSubsurfaceScatteringEnabled");
static_assert(sizeof(PhxGameUserSettings_SetSubsurfaceScatteringEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_SetSubsurfaceScatteringEnabled");
static_assert(offsetof(PhxGameUserSettings_SetSubsurfaceScatteringEnabled, bInSubsurfaceScatteringEnabled) == 0x000000, "Member 'PhxGameUserSettings_SetSubsurfaceScatteringEnabled::bInSubsurfaceScatteringEnabled' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSurvivalNGPlusUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetSurvivalNGPlusUnlockDisplayed final
{
public:
	bool                                          bInIsDisplayed;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSurvivalNGPlusUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetSurvivalNGPlusUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_SetSurvivalNGPlusUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_SetSurvivalNGPlusUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_SetSurvivalNGPlusUnlockDisplayed, bInIsDisplayed) == 0x000000, "Member 'PhxGameUserSettings_SetSurvivalNGPlusUnlockDisplayed::bInIsDisplayed' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetSurvivalUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetSurvivalUnlockDisplayed final
{
public:
	bool                                          bInIsDisplayed;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetSurvivalUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetSurvivalUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_SetSurvivalUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_SetSurvivalUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_SetSurvivalUnlockDisplayed, bInIsDisplayed) == 0x000000, "Member 'PhxGameUserSettings_SetSurvivalUnlockDisplayed::bInIsDisplayed' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetTextCulture
// 0x0018 (0x0018 - 0x0000)
struct PhxGameUserSettings_SetTextCulture final
{
public:
	class FString                                 CultureCode;                                       // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSetByUser;                                        // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameUserSettings_SetTextCulture) == 0x000008, "Wrong alignment on PhxGameUserSettings_SetTextCulture");
static_assert(sizeof(PhxGameUserSettings_SetTextCulture) == 0x000018, "Wrong size on PhxGameUserSettings_SetTextCulture");
static_assert(offsetof(PhxGameUserSettings_SetTextCulture, CultureCode) == 0x000000, "Member 'PhxGameUserSettings_SetTextCulture::CultureCode' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_SetTextCulture, bSetByUser) == 0x000010, "Member 'PhxGameUserSettings_SetTextCulture::bSetByUser' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetTextureFilterQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetTextureFilterQuality final
{
public:
	EGraphicsQuality                              InTextureFilterQuality;                            // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetTextureFilterQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetTextureFilterQuality");
static_assert(sizeof(PhxGameUserSettings_SetTextureFilterQuality) == 0x000001, "Wrong size on PhxGameUserSettings_SetTextureFilterQuality");
static_assert(offsetof(PhxGameUserSettings_SetTextureFilterQuality, InTextureFilterQuality) == 0x000000, "Member 'PhxGameUserSettings_SetTextureFilterQuality::InTextureFilterQuality' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetTextureResolutionQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetTextureResolutionQuality final
{
public:
	EGraphicsQuality                              InTextureResolutionQuality;                        // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetTextureResolutionQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetTextureResolutionQuality");
static_assert(sizeof(PhxGameUserSettings_SetTextureResolutionQuality) == 0x000001, "Wrong size on PhxGameUserSettings_SetTextureResolutionQuality");
static_assert(offsetof(PhxGameUserSettings_SetTextureResolutionQuality, InTextureResolutionQuality) == 0x000000, "Member 'PhxGameUserSettings_SetTextureResolutionQuality::InTextureResolutionQuality' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetUpscalingMode
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetUpscalingMode final
{
public:
	EUpscalingMode                                bInUpscalingMode;                                  // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetUpscalingMode) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetUpscalingMode");
static_assert(sizeof(PhxGameUserSettings_SetUpscalingMode) == 0x000001, "Wrong size on PhxGameUserSettings_SetUpscalingMode");
static_assert(offsetof(PhxGameUserSettings_SetUpscalingMode, bInUpscalingMode) == 0x000000, "Member 'PhxGameUserSettings_SetUpscalingMode::bInUpscalingMode' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetUserScreenResolution
// 0x000C (0x000C - 0x0000)
struct PhxGameUserSettings_SetUserScreenResolution final
{
public:
	EWindowMode                                   InWindowMode;                                      // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FIntPoint                              InResolution;                                      // 0x0004(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetUserScreenResolution) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetUserScreenResolution");
static_assert(sizeof(PhxGameUserSettings_SetUserScreenResolution) == 0x00000C, "Wrong size on PhxGameUserSettings_SetUserScreenResolution");
static_assert(offsetof(PhxGameUserSettings_SetUserScreenResolution, InWindowMode) == 0x000000, "Member 'PhxGameUserSettings_SetUserScreenResolution::InWindowMode' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_SetUserScreenResolution, InResolution) == 0x000004, "Member 'PhxGameUserSettings_SetUserScreenResolution::InResolution' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetVolumetricsQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetVolumetricsQuality final
{
public:
	EGraphicsQuality                              InVolumetricsQuality;                              // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetVolumetricsQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetVolumetricsQuality");
static_assert(sizeof(PhxGameUserSettings_SetVolumetricsQuality) == 0x000001, "Wrong size on PhxGameUserSettings_SetVolumetricsQuality");
static_assert(offsetof(PhxGameUserSettings_SetVolumetricsQuality, InVolumetricsQuality) == 0x000000, "Member 'PhxGameUserSettings_SetVolumetricsQuality::InVolumetricsQuality' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetWantedHDROutput
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SetWantedHDROutput final
{
public:
	bool                                          bInWantedHDROutput;                                // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetWantedHDROutput) == 0x000001, "Wrong alignment on PhxGameUserSettings_SetWantedHDROutput");
static_assert(sizeof(PhxGameUserSettings_SetWantedHDROutput) == 0x000001, "Wrong size on PhxGameUserSettings_SetWantedHDROutput");
static_assert(offsetof(PhxGameUserSettings_SetWantedHDROutput, bInWantedHDROutput) == 0x000000, "Member 'PhxGameUserSettings_SetWantedHDROutput::bInWantedHDROutput' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SetWantedPeakNits
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_SetWantedPeakNits final
{
public:
	float                                         InWantedPeakNits;                                  // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SetWantedPeakNits) == 0x000004, "Wrong alignment on PhxGameUserSettings_SetWantedPeakNits");
static_assert(sizeof(PhxGameUserSettings_SetWantedPeakNits) == 0x000004, "Wrong size on PhxGameUserSettings_SetWantedPeakNits");
static_assert(offsetof(PhxGameUserSettings_SetWantedPeakNits, InWantedPeakNits) == 0x000000, "Member 'PhxGameUserSettings_SetWantedPeakNits::InWantedPeakNits' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.AvailableDialogLanguages
// 0x0050 (0x0050 - 0x0000)
struct PhxGameUserSettings_AvailableDialogLanguages final
{
public:
	TMap<class FString, class FText>              ReturnValue;                                       // 0x0000(0x0050)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_AvailableDialogLanguages) == 0x000008, "Wrong alignment on PhxGameUserSettings_AvailableDialogLanguages");
static_assert(sizeof(PhxGameUserSettings_AvailableDialogLanguages) == 0x000050, "Wrong size on PhxGameUserSettings_AvailableDialogLanguages");
static_assert(offsetof(PhxGameUserSettings_AvailableDialogLanguages, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_AvailableDialogLanguages::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetActionKeyMappingList
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetActionKeyMappingList final
{
public:
	TArray<struct FPhxInputActionMappingSetting>  ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetActionKeyMappingList) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetActionKeyMappingList");
static_assert(sizeof(PhxGameUserSettings_GetActionKeyMappingList) == 0x000010, "Wrong size on PhxGameUserSettings_GetActionKeyMappingList");
static_assert(offsetof(PhxGameUserSettings_GetActionKeyMappingList, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetActionKeyMappingList::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetAimAssistEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetAimAssistEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetAimAssistEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetAimAssistEnabled");
static_assert(sizeof(PhxGameUserSettings_GetAimAssistEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetAimAssistEnabled");
static_assert(offsetof(PhxGameUserSettings_GetAimAssistEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetAimAssistEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetAimAssistStrength
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetAimAssistStrength final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetAimAssistStrength) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetAimAssistStrength");
static_assert(sizeof(PhxGameUserSettings_GetAimAssistStrength) == 0x000004, "Wrong size on PhxGameUserSettings_GetAimAssistStrength");
static_assert(offsetof(PhxGameUserSettings_GetAimAssistStrength, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetAimAssistStrength::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetAimParallaxEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetAimParallaxEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetAimParallaxEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetAimParallaxEnabled");
static_assert(sizeof(PhxGameUserSettings_GetAimParallaxEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetAimParallaxEnabled");
static_assert(offsetof(PhxGameUserSettings_GetAimParallaxEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetAimParallaxEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetAimSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetAimSensitivity final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetAimSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetAimSensitivity");
static_assert(sizeof(PhxGameUserSettings_GetAimSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_GetAimSensitivity");
static_assert(offsetof(PhxGameUserSettings_GetAimSensitivity, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetAimSensitivity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetAntiAliasingMethod
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetAntiAliasingMethod final
{
public:
	EAntiAliasingMethod                           ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetAntiAliasingMethod) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetAntiAliasingMethod");
static_assert(sizeof(PhxGameUserSettings_GetAntiAliasingMethod) == 0x000001, "Wrong size on PhxGameUserSettings_GetAntiAliasingMethod");
static_assert(offsetof(PhxGameUserSettings_GetAntiAliasingMethod, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetAntiAliasingMethod::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetAutoAimEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetAutoAimEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetAutoAimEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetAutoAimEnabled");
static_assert(sizeof(PhxGameUserSettings_GetAutoAimEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetAutoAimEnabled");
static_assert(offsetof(PhxGameUserSettings_GetAutoAimEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetAutoAimEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetAutoDodgeEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetAutoDodgeEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetAutoDodgeEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetAutoDodgeEnabled");
static_assert(sizeof(PhxGameUserSettings_GetAutoDodgeEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetAutoDodgeEnabled");
static_assert(offsetof(PhxGameUserSettings_GetAutoDodgeEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetAutoDodgeEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetAxisKeyMappingList
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetAxisKeyMappingList final
{
public:
	TArray<struct FPhxInputAxisMappingSetting>    ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetAxisKeyMappingList) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetAxisKeyMappingList");
static_assert(sizeof(PhxGameUserSettings_GetAxisKeyMappingList) == 0x000010, "Wrong size on PhxGameUserSettings_GetAxisKeyMappingList");
static_assert(offsetof(PhxGameUserSettings_GetAxisKeyMappingList, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetAxisKeyMappingList::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetBenchmarkMode
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetBenchmarkMode final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetBenchmarkMode) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetBenchmarkMode");
static_assert(sizeof(PhxGameUserSettings_GetBenchmarkMode) == 0x000001, "Wrong size on PhxGameUserSettings_GetBenchmarkMode");
static_assert(offsetof(PhxGameUserSettings_GetBenchmarkMode, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetBenchmarkMode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetBlackPointValue
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetBlackPointValue final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetBlackPointValue) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetBlackPointValue");
static_assert(sizeof(PhxGameUserSettings_GetBlackPointValue) == 0x000004, "Wrong size on PhxGameUserSettings_GetBlackPointValue");
static_assert(offsetof(PhxGameUserSettings_GetBlackPointValue, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetBlackPointValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetButtonHoldAssistEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetButtonHoldAssistEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetButtonHoldAssistEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetButtonHoldAssistEnabled");
static_assert(sizeof(PhxGameUserSettings_GetButtonHoldAssistEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetButtonHoldAssistEnabled");
static_assert(offsetof(PhxGameUserSettings_GetButtonHoldAssistEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetButtonHoldAssistEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetButtonPromptSize
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetButtonPromptSize final
{
public:
	ESDSSize                                      ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetButtonPromptSize) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetButtonPromptSize");
static_assert(sizeof(PhxGameUserSettings_GetButtonPromptSize) == 0x000001, "Wrong size on PhxGameUserSettings_GetButtonPromptSize");
static_assert(offsetof(PhxGameUserSettings_GetButtonPromptSize, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetButtonPromptSize::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetCameraShakeIntensity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetCameraShakeIntensity final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetCameraShakeIntensity) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetCameraShakeIntensity");
static_assert(sizeof(PhxGameUserSettings_GetCameraShakeIntensity) == 0x000004, "Wrong size on PhxGameUserSettings_GetCameraShakeIntensity");
static_assert(offsetof(PhxGameUserSettings_GetCameraShakeIntensity, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetCameraShakeIntensity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetCameraTwistIntensity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetCameraTwistIntensity final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetCameraTwistIntensity) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetCameraTwistIntensity");
static_assert(sizeof(PhxGameUserSettings_GetCameraTwistIntensity) == 0x000004, "Wrong size on PhxGameUserSettings_GetCameraTwistIntensity");
static_assert(offsetof(PhxGameUserSettings_GetCameraTwistIntensity, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetCameraTwistIntensity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetControllerSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetControllerSensitivity final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetControllerSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetControllerSensitivity");
static_assert(sizeof(PhxGameUserSettings_GetControllerSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_GetControllerSensitivity");
static_assert(offsetof(PhxGameUserSettings_GetControllerSensitivity, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetControllerSensitivity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetDialogCulture
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetDialogCulture final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetDialogCulture) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetDialogCulture");
static_assert(sizeof(PhxGameUserSettings_GetDialogCulture) == 0x000010, "Wrong size on PhxGameUserSettings_GetDialogCulture");
static_assert(offsetof(PhxGameUserSettings_GetDialogCulture, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetDialogCulture::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetDialogueVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetDialogueVolume final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetDialogueVolume) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetDialogueVolume");
static_assert(sizeof(PhxGameUserSettings_GetDialogueVolume) == 0x000004, "Wrong size on PhxGameUserSettings_GetDialogueVolume");
static_assert(offsetof(PhxGameUserSettings_GetDialogueVolume, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetDialogueVolume::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetDifficultyLevel
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetDifficultyLevel final
{
public:
	EPhxDifficultyLevel                           ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetDifficultyLevel) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetDifficultyLevel");
static_assert(sizeof(PhxGameUserSettings_GetDifficultyLevel) == 0x000001, "Wrong size on PhxGameUserSettings_GetDifficultyLevel");
static_assert(offsetof(PhxGameUserSettings_GetDifficultyLevel, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetDifficultyLevel::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetDirectXRHI
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetDirectXRHI final
{
public:
	EDirectXRHI                                   ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetDirectXRHI) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetDirectXRHI");
static_assert(sizeof(PhxGameUserSettings_GetDirectXRHI) == 0x000001, "Wrong size on PhxGameUserSettings_GetDirectXRHI");
static_assert(offsetof(PhxGameUserSettings_GetDirectXRHI, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetDirectXRHI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetDirectXRHIInUse
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetDirectXRHIInUse final
{
public:
	EDirectXRHI                                   ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetDirectXRHIInUse) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetDirectXRHIInUse");
static_assert(sizeof(PhxGameUserSettings_GetDirectXRHIInUse) == 0x000001, "Wrong size on PhxGameUserSettings_GetDirectXRHIInUse");
static_assert(offsetof(PhxGameUserSettings_GetDirectXRHIInUse, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetDirectXRHIInUse::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetDisplayType
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetDisplayType final
{
public:
	EPhxDisplayType                               ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetDisplayType) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetDisplayType");
static_assert(sizeof(PhxGameUserSettings_GetDisplayType) == 0x000001, "Wrong size on PhxGameUserSettings_GetDisplayType");
static_assert(offsetof(PhxGameUserSettings_GetDisplayType, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetDisplayType::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetDLCNotificationIcon
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetDLCNotificationIcon final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetDLCNotificationIcon) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetDLCNotificationIcon");
static_assert(sizeof(PhxGameUserSettings_GetDLCNotificationIcon) == 0x000001, "Wrong size on PhxGameUserSettings_GetDLCNotificationIcon");
static_assert(offsetof(PhxGameUserSettings_GetDLCNotificationIcon, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetDLCNotificationIcon::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetDyslexicFontEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetDyslexicFontEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetDyslexicFontEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetDyslexicFontEnabled");
static_assert(sizeof(PhxGameUserSettings_GetDyslexicFontEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetDyslexicFontEnabled");
static_assert(offsetof(PhxGameUserSettings_GetDyslexicFontEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetDyslexicFontEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetFSR2Mode
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetFSR2Mode final
{
public:
	EFSR2QualityModeWrapper                       ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetFSR2Mode) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetFSR2Mode");
static_assert(sizeof(PhxGameUserSettings_GetFSR2Mode) == 0x000001, "Wrong size on PhxGameUserSettings_GetFSR2Mode");
static_assert(offsetof(PhxGameUserSettings_GetFSR2Mode, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetFSR2Mode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetGoreEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetGoreEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetGoreEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetGoreEnabled");
static_assert(sizeof(PhxGameUserSettings_GetGoreEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetGoreEnabled");
static_assert(offsetof(PhxGameUserSettings_GetGoreEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetGoreEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetGyroAimEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetGyroAimEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetGyroAimEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetGyroAimEnabled");
static_assert(sizeof(PhxGameUserSettings_GetGyroAimEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetGyroAimEnabled");
static_assert(offsetof(PhxGameUserSettings_GetGyroAimEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetGyroAimEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetGyroAimSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetGyroAimSensitivity final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetGyroAimSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetGyroAimSensitivity");
static_assert(sizeof(PhxGameUserSettings_GetGyroAimSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_GetGyroAimSensitivity");
static_assert(offsetof(PhxGameUserSettings_GetGyroAimSensitivity, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetGyroAimSensitivity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHallucinationFXEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetHallucinationFXEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHallucinationFXEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetHallucinationFXEnabled");
static_assert(sizeof(PhxGameUserSettings_GetHallucinationFXEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetHallucinationFXEnabled");
static_assert(offsetof(PhxGameUserSettings_GetHallucinationFXEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHallucinationFXEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHasShownNewGamePlusNotification
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetHasShownNewGamePlusNotification final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHasShownNewGamePlusNotification) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetHasShownNewGamePlusNotification");
static_assert(sizeof(PhxGameUserSettings_GetHasShownNewGamePlusNotification) == 0x000001, "Wrong size on PhxGameUserSettings_GetHasShownNewGamePlusNotification");
static_assert(offsetof(PhxGameUserSettings_GetHasShownNewGamePlusNotification, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHasShownNewGamePlusNotification::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHCEnemyColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetHCEnemyColor final
{
public:
	struct FLinearColor                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHCEnemyColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetHCEnemyColor");
static_assert(sizeof(PhxGameUserSettings_GetHCEnemyColor) == 0x000010, "Wrong size on PhxGameUserSettings_GetHCEnemyColor");
static_assert(offsetof(PhxGameUserSettings_GetHCEnemyColor, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHCEnemyColor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHCHazardColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetHCHazardColor final
{
public:
	struct FLinearColor                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHCHazardColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetHCHazardColor");
static_assert(sizeof(PhxGameUserSettings_GetHCHazardColor) == 0x000010, "Wrong size on PhxGameUserSettings_GetHCHazardColor");
static_assert(offsetof(PhxGameUserSettings_GetHCHazardColor, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHCHazardColor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHCPickupColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetHCPickupColor final
{
public:
	struct FLinearColor                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHCPickupColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetHCPickupColor");
static_assert(sizeof(PhxGameUserSettings_GetHCPickupColor) == 0x000010, "Wrong size on PhxGameUserSettings_GetHCPickupColor");
static_assert(offsetof(PhxGameUserSettings_GetHCPickupColor, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHCPickupColor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHCPlayerColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetHCPlayerColor final
{
public:
	struct FLinearColor                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHCPlayerColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetHCPlayerColor");
static_assert(sizeof(PhxGameUserSettings_GetHCPlayerColor) == 0x000010, "Wrong size on PhxGameUserSettings_GetHCPlayerColor");
static_assert(offsetof(PhxGameUserSettings_GetHCPlayerColor, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHCPlayerColor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHDRBlackPointCorrection
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetHDRBlackPointCorrection final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHDRBlackPointCorrection) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetHDRBlackPointCorrection");
static_assert(sizeof(PhxGameUserSettings_GetHDRBlackPointCorrection) == 0x000004, "Wrong size on PhxGameUserSettings_GetHDRBlackPointCorrection");
static_assert(offsetof(PhxGameUserSettings_GetHDRBlackPointCorrection, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHDRBlackPointCorrection::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHDRBrightness
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetHDRBrightness final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHDRBrightness) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetHDRBrightness");
static_assert(sizeof(PhxGameUserSettings_GetHDRBrightness) == 0x000004, "Wrong size on PhxGameUserSettings_GetHDRBrightness");
static_assert(offsetof(PhxGameUserSettings_GetHDRBrightness, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHDRBrightness::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHDRSupportStatus
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetHDRSupportStatus final
{
public:
	EHDRSupportStatus                             ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHDRSupportStatus) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetHDRSupportStatus");
static_assert(sizeof(PhxGameUserSettings_GetHDRSupportStatus) == 0x000001, "Wrong size on PhxGameUserSettings_GetHDRSupportStatus");
static_assert(offsetof(PhxGameUserSettings_GetHDRSupportStatus, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHDRSupportStatus::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHideBrightnessFlow
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetHideBrightnessFlow final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHideBrightnessFlow) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetHideBrightnessFlow");
static_assert(sizeof(PhxGameUserSettings_GetHideBrightnessFlow) == 0x000001, "Wrong size on PhxGameUserSettings_GetHideBrightnessFlow");
static_assert(offsetof(PhxGameUserSettings_GetHideBrightnessFlow, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHideBrightnessFlow::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHighContrastEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetHighContrastEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHighContrastEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetHighContrastEnabled");
static_assert(sizeof(PhxGameUserSettings_GetHighContrastEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetHighContrastEnabled");
static_assert(offsetof(PhxGameUserSettings_GetHighContrastEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHighContrastEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHighScoreList
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetHighScoreList final
{
public:
	TArray<struct FPhxHighScoreRecord>            ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHighScoreList) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetHighScoreList");
static_assert(sizeof(PhxGameUserSettings_GetHighScoreList) == 0x000010, "Wrong size on PhxGameUserSettings_GetHighScoreList");
static_assert(offsetof(PhxGameUserSettings_GetHighScoreList, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHighScoreList::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetHighScoreListSize
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetHighScoreListSize final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetHighScoreListSize) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetHighScoreListSize");
static_assert(sizeof(PhxGameUserSettings_GetHighScoreListSize) == 0x000004, "Wrong size on PhxGameUserSettings_GetHighScoreListSize");
static_assert(offsetof(PhxGameUserSettings_GetHighScoreListSize, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetHighScoreListSize::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetInputMappingSettings
// 0x0028 (0x0028 - 0x0000)
struct PhxGameUserSettings_GetInputMappingSettings final
{
public:
	TSoftObjectPtr<class UPhxInputMappingSettings> ReturnValue;                                      // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetInputMappingSettings) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetInputMappingSettings");
static_assert(sizeof(PhxGameUserSettings_GetInputMappingSettings) == 0x000028, "Wrong size on PhxGameUserSettings_GetInputMappingSettings");
static_assert(offsetof(PhxGameUserSettings_GetInputMappingSettings, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetInputMappingSettings::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetInventoryParallaxEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetInventoryParallaxEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetInventoryParallaxEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetInventoryParallaxEnabled");
static_assert(sizeof(PhxGameUserSettings_GetInventoryParallaxEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetInventoryParallaxEnabled");
static_assert(offsetof(PhxGameUserSettings_GetInventoryParallaxEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetInventoryParallaxEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetInvertMouseX
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetInvertMouseX final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetInvertMouseX) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetInvertMouseX");
static_assert(sizeof(PhxGameUserSettings_GetInvertMouseX) == 0x000001, "Wrong size on PhxGameUserSettings_GetInvertMouseX");
static_assert(offsetof(PhxGameUserSettings_GetInvertMouseX, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetInvertMouseX::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetInvertMouseY
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetInvertMouseY final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetInvertMouseY) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetInvertMouseY");
static_assert(sizeof(PhxGameUserSettings_GetInvertMouseY) == 0x000001, "Wrong size on PhxGameUserSettings_GetInvertMouseY");
static_assert(offsetof(PhxGameUserSettings_GetInvertMouseY, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetInvertMouseY::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetInvertX
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetInvertX final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetInvertX) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetInvertX");
static_assert(sizeof(PhxGameUserSettings_GetInvertX) == 0x000001, "Wrong size on PhxGameUserSettings_GetInvertX");
static_assert(offsetof(PhxGameUserSettings_GetInvertX, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetInvertX::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetInvertY
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetInvertY final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetInvertY) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetInvertY");
static_assert(sizeof(PhxGameUserSettings_GetInvertY) == 0x000001, "Wrong size on PhxGameUserSettings_GetInvertY");
static_assert(offsetof(PhxGameUserSettings_GetInvertY, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetInvertY::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetLastDLCStoreUnlockID
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetLastDLCStoreUnlockID final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetLastDLCStoreUnlockID) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetLastDLCStoreUnlockID");
static_assert(sizeof(PhxGameUserSettings_GetLastDLCStoreUnlockID) == 0x000004, "Wrong size on PhxGameUserSettings_GetLastDLCStoreUnlockID");
static_assert(offsetof(PhxGameUserSettings_GetLastDLCStoreUnlockID, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetLastDLCStoreUnlockID::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetLastScoreIndex
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetLastScoreIndex final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetLastScoreIndex) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetLastScoreIndex");
static_assert(sizeof(PhxGameUserSettings_GetLastScoreIndex) == 0x000004, "Wrong size on PhxGameUserSettings_GetLastScoreIndex");
static_assert(offsetof(PhxGameUserSettings_GetLastScoreIndex, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetLastScoreIndex::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetLightingQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetLightingQuality final
{
public:
	EGraphicsQuality                              ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetLightingQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetLightingQuality");
static_assert(sizeof(PhxGameUserSettings_GetLightingQuality) == 0x000001, "Wrong size on PhxGameUserSettings_GetLightingQuality");
static_assert(offsetof(PhxGameUserSettings_GetLightingQuality, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetLightingQuality::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetLookSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetLookSensitivity final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetLookSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetLookSensitivity");
static_assert(sizeof(PhxGameUserSettings_GetLookSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_GetLookSensitivity");
static_assert(offsetof(PhxGameUserSettings_GetLookSensitivity, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetLookSensitivity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetLowHealthFXEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetLowHealthFXEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetLowHealthFXEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetLowHealthFXEnabled");
static_assert(sizeof(PhxGameUserSettings_GetLowHealthFXEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetLowHealthFXEnabled");
static_assert(offsetof(PhxGameUserSettings_GetLowHealthFXEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetLowHealthFXEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetMeleeHoldEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetMeleeHoldEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetMeleeHoldEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetMeleeHoldEnabled");
static_assert(sizeof(PhxGameUserSettings_GetMeleeHoldEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetMeleeHoldEnabled");
static_assert(offsetof(PhxGameUserSettings_GetMeleeHoldEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetMeleeHoldEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetMenuReaderEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetMenuReaderEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetMenuReaderEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetMenuReaderEnabled");
static_assert(sizeof(PhxGameUserSettings_GetMenuReaderEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetMenuReaderEnabled");
static_assert(offsetof(PhxGameUserSettings_GetMenuReaderEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetMenuReaderEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetMeshQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetMeshQuality final
{
public:
	EGraphicsQuality                              ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetMeshQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetMeshQuality");
static_assert(sizeof(PhxGameUserSettings_GetMeshQuality) == 0x000001, "Wrong size on PhxGameUserSettings_GetMeshQuality");
static_assert(offsetof(PhxGameUserSettings_GetMeshQuality, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetMeshQuality::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetMouseAimSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetMouseAimSensitivity final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetMouseAimSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetMouseAimSensitivity");
static_assert(sizeof(PhxGameUserSettings_GetMouseAimSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_GetMouseAimSensitivity");
static_assert(offsetof(PhxGameUserSettings_GetMouseAimSensitivity, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetMouseAimSensitivity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetMouseAimSmoothingEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetMouseAimSmoothingEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetMouseAimSmoothingEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetMouseAimSmoothingEnabled");
static_assert(sizeof(PhxGameUserSettings_GetMouseAimSmoothingEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetMouseAimSmoothingEnabled");
static_assert(offsetof(PhxGameUserSettings_GetMouseAimSmoothingEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetMouseAimSmoothingEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetMouseLookSensitivity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetMouseLookSensitivity final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetMouseLookSensitivity) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetMouseLookSensitivity");
static_assert(sizeof(PhxGameUserSettings_GetMouseLookSensitivity) == 0x000004, "Wrong size on PhxGameUserSettings_GetMouseLookSensitivity");
static_assert(offsetof(PhxGameUserSettings_GetMouseLookSensitivity, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetMouseLookSensitivity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetMouseLookSmoothingEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetMouseLookSmoothingEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetMouseLookSmoothingEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetMouseLookSmoothingEnabled");
static_assert(sizeof(PhxGameUserSettings_GetMouseLookSmoothingEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetMouseLookSmoothingEnabled");
static_assert(offsetof(PhxGameUserSettings_GetMouseLookSmoothingEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetMouseLookSmoothingEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetMusicVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetMusicVolume final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetMusicVolume) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetMusicVolume");
static_assert(sizeof(PhxGameUserSettings_GetMusicVolume) == 0x000004, "Wrong size on PhxGameUserSettings_GetMusicVolume");
static_assert(offsetof(PhxGameUserSettings_GetMusicVolume, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetMusicVolume::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetParticleQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetParticleQuality final
{
public:
	EGraphicsQuality                              ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetParticleQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetParticleQuality");
static_assert(sizeof(PhxGameUserSettings_GetParticleQuality) == 0x000001, "Wrong size on PhxGameUserSettings_GetParticleQuality");
static_assert(offsetof(PhxGameUserSettings_GetParticleQuality, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetParticleQuality::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetPlayerSkinIndex
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetPlayerSkinIndex final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetPlayerSkinIndex) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetPlayerSkinIndex");
static_assert(sizeof(PhxGameUserSettings_GetPlayerSkinIndex) == 0x000004, "Wrong size on PhxGameUserSettings_GetPlayerSkinIndex");
static_assert(offsetof(PhxGameUserSettings_GetPlayerSkinIndex, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetPlayerSkinIndex::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetQTEAutoCompleteEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetQTEAutoCompleteEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetQTEAutoCompleteEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetQTEAutoCompleteEnabled");
static_assert(sizeof(PhxGameUserSettings_GetQTEAutoCompleteEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetQTEAutoCompleteEnabled");
static_assert(offsetof(PhxGameUserSettings_GetQTEAutoCompleteEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetQTEAutoCompleteEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetQTESinglePressEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetQTESinglePressEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetQTESinglePressEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetQTESinglePressEnabled");
static_assert(sizeof(PhxGameUserSettings_GetQTESinglePressEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetQTESinglePressEnabled");
static_assert(offsetof(PhxGameUserSettings_GetQTESinglePressEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetQTESinglePressEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetRadioBanterChannel
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetRadioBanterChannel final
{
public:
	EPhxRadioBanterChannel                        ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetRadioBanterChannel) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetRadioBanterChannel");
static_assert(sizeof(PhxGameUserSettings_GetRadioBanterChannel) == 0x000001, "Wrong size on PhxGameUserSettings_GetRadioBanterChannel");
static_assert(offsetof(PhxGameUserSettings_GetRadioBanterChannel, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetRadioBanterChannel::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetRadioBanterVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetRadioBanterVolume final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetRadioBanterVolume) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetRadioBanterVolume");
static_assert(sizeof(PhxGameUserSettings_GetRadioBanterVolume) == 0x000004, "Wrong size on PhxGameUserSettings_GetRadioBanterVolume");
static_assert(offsetof(PhxGameUserSettings_GetRadioBanterVolume, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetRadioBanterVolume::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetRaytracedReflectionsQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetRaytracedReflectionsQuality final
{
public:
	EGraphicsQuality                              ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetRaytracedReflectionsQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetRaytracedReflectionsQuality");
static_assert(sizeof(PhxGameUserSettings_GetRaytracedReflectionsQuality) == 0x000001, "Wrong size on PhxGameUserSettings_GetRaytracedReflectionsQuality");
static_assert(offsetof(PhxGameUserSettings_GetRaytracedReflectionsQuality, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetRaytracedReflectionsQuality::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetRenderResolutionPercentage
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetRenderResolutionPercentage final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetRenderResolutionPercentage) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetRenderResolutionPercentage");
static_assert(sizeof(PhxGameUserSettings_GetRenderResolutionPercentage) == 0x000004, "Wrong size on PhxGameUserSettings_GetRenderResolutionPercentage");
static_assert(offsetof(PhxGameUserSettings_GetRenderResolutionPercentage, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetRenderResolutionPercentage::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetRiotModeCreditsSpent
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetRiotModeCreditsSpent final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetRiotModeCreditsSpent) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetRiotModeCreditsSpent");
static_assert(sizeof(PhxGameUserSettings_GetRiotModeCreditsSpent) == 0x000004, "Wrong size on PhxGameUserSettings_GetRiotModeCreditsSpent");
static_assert(offsetof(PhxGameUserSettings_GetRiotModeCreditsSpent, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetRiotModeCreditsSpent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetRiotPowerupActivationCount
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetRiotPowerupActivationCount final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetRiotPowerupActivationCount) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetRiotPowerupActivationCount");
static_assert(sizeof(PhxGameUserSettings_GetRiotPowerupActivationCount) == 0x000004, "Wrong size on PhxGameUserSettings_GetRiotPowerupActivationCount");
static_assert(offsetof(PhxGameUserSettings_GetRiotPowerupActivationCount, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetRiotPowerupActivationCount::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSFXVolume
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetSFXVolume final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSFXVolume) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetSFXVolume");
static_assert(sizeof(PhxGameUserSettings_GetSFXVolume) == 0x000004, "Wrong size on PhxGameUserSettings_GetSFXVolume");
static_assert(offsetof(PhxGameUserSettings_GetSFXVolume, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetSFXVolume::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetShadowMapQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetShadowMapQuality final
{
public:
	EGraphicsQuality                              ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetShadowMapQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetShadowMapQuality");
static_assert(sizeof(PhxGameUserSettings_GetShadowMapQuality) == 0x000001, "Wrong size on PhxGameUserSettings_GetShadowMapQuality");
static_assert(offsetof(PhxGameUserSettings_GetShadowMapQuality, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetShadowMapQuality::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetShowRiotModeRules
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetShowRiotModeRules final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetShowRiotModeRules) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetShowRiotModeRules");
static_assert(sizeof(PhxGameUserSettings_GetShowRiotModeRules) == 0x000001, "Wrong size on PhxGameUserSettings_GetShowRiotModeRules");
static_assert(offsetof(PhxGameUserSettings_GetShowRiotModeRules, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetShowRiotModeRules::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSubsBGColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetSubsBGColor final
{
public:
	struct FLinearColor                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSubsBGColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetSubsBGColor");
static_assert(sizeof(PhxGameUserSettings_GetSubsBGColor) == 0x000010, "Wrong size on PhxGameUserSettings_GetSubsBGColor");
static_assert(offsetof(PhxGameUserSettings_GetSubsBGColor, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetSubsBGColor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSubsBGEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetSubsBGEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSubsBGEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetSubsBGEnabled");
static_assert(sizeof(PhxGameUserSettings_GetSubsBGEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetSubsBGEnabled");
static_assert(offsetof(PhxGameUserSettings_GetSubsBGEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetSubsBGEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSubsBGOpacity
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetSubsBGOpacity final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSubsBGOpacity) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetSubsBGOpacity");
static_assert(sizeof(PhxGameUserSettings_GetSubsBGOpacity) == 0x000004, "Wrong size on PhxGameUserSettings_GetSubsBGOpacity");
static_assert(offsetof(PhxGameUserSettings_GetSubsBGOpacity, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetSubsBGOpacity::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSubsCulture
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetSubsCulture final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSubsCulture) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetSubsCulture");
static_assert(sizeof(PhxGameUserSettings_GetSubsCulture) == 0x000010, "Wrong size on PhxGameUserSettings_GetSubsCulture");
static_assert(offsetof(PhxGameUserSettings_GetSubsCulture, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetSubsCulture::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSubsEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetSubsEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSubsEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetSubsEnabled");
static_assert(sizeof(PhxGameUserSettings_GetSubsEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetSubsEnabled");
static_assert(offsetof(PhxGameUserSettings_GetSubsEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetSubsEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSubsFontColor
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetSubsFontColor final
{
public:
	struct FLinearColor                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSubsFontColor) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetSubsFontColor");
static_assert(sizeof(PhxGameUserSettings_GetSubsFontColor) == 0x000010, "Wrong size on PhxGameUserSettings_GetSubsFontColor");
static_assert(offsetof(PhxGameUserSettings_GetSubsFontColor, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetSubsFontColor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSubsFontScale
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetSubsFontScale final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSubsFontScale) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetSubsFontScale");
static_assert(sizeof(PhxGameUserSettings_GetSubsFontScale) == 0x000004, "Wrong size on PhxGameUserSettings_GetSubsFontScale");
static_assert(offsetof(PhxGameUserSettings_GetSubsFontScale, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetSubsFontScale::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSubsSpeakerColor
// 0x0020 (0x0020 - 0x0000)
struct PhxGameUserSettings_GetSubsSpeakerColor final
{
public:
	class FString                                 OutHex;                                            // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ReturnValue;                                       // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSubsSpeakerColor) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetSubsSpeakerColor");
static_assert(sizeof(PhxGameUserSettings_GetSubsSpeakerColor) == 0x000020, "Wrong size on PhxGameUserSettings_GetSubsSpeakerColor");
static_assert(offsetof(PhxGameUserSettings_GetSubsSpeakerColor, OutHex) == 0x000000, "Member 'PhxGameUserSettings_GetSubsSpeakerColor::OutHex' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_GetSubsSpeakerColor, ReturnValue) == 0x000010, "Member 'PhxGameUserSettings_GetSubsSpeakerColor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetSubsSpeakerEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetSubsSpeakerEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetSubsSpeakerEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetSubsSpeakerEnabled");
static_assert(sizeof(PhxGameUserSettings_GetSubsSpeakerEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_GetSubsSpeakerEnabled");
static_assert(offsetof(PhxGameUserSettings_GetSubsSpeakerEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetSubsSpeakerEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetTextCulture
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetTextCulture final
{
public:
	class FString                                 ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetTextCulture) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetTextCulture");
static_assert(sizeof(PhxGameUserSettings_GetTextCulture) == 0x000010, "Wrong size on PhxGameUserSettings_GetTextCulture");
static_assert(offsetof(PhxGameUserSettings_GetTextCulture, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetTextCulture::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetTextureFilterQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetTextureFilterQuality final
{
public:
	EGraphicsQuality                              ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetTextureFilterQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetTextureFilterQuality");
static_assert(sizeof(PhxGameUserSettings_GetTextureFilterQuality) == 0x000001, "Wrong size on PhxGameUserSettings_GetTextureFilterQuality");
static_assert(offsetof(PhxGameUserSettings_GetTextureFilterQuality, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetTextureFilterQuality::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetTextureResolutionQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetTextureResolutionQuality final
{
public:
	EGraphicsQuality                              ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetTextureResolutionQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetTextureResolutionQuality");
static_assert(sizeof(PhxGameUserSettings_GetTextureResolutionQuality) == 0x000001, "Wrong size on PhxGameUserSettings_GetTextureResolutionQuality");
static_assert(offsetof(PhxGameUserSettings_GetTextureResolutionQuality, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetTextureResolutionQuality::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetUnlockedRiotModePerks
// 0x0010 (0x0010 - 0x0000)
struct PhxGameUserSettings_GetUnlockedRiotModePerks final
{
public:
	TArray<EPhxRiotModePerkType>                  ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetUnlockedRiotModePerks) == 0x000008, "Wrong alignment on PhxGameUserSettings_GetUnlockedRiotModePerks");
static_assert(sizeof(PhxGameUserSettings_GetUnlockedRiotModePerks) == 0x000010, "Wrong size on PhxGameUserSettings_GetUnlockedRiotModePerks");
static_assert(offsetof(PhxGameUserSettings_GetUnlockedRiotModePerks, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetUnlockedRiotModePerks::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetUpscalingMode
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetUpscalingMode final
{
public:
	EUpscalingMode                                ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetUpscalingMode) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetUpscalingMode");
static_assert(sizeof(PhxGameUserSettings_GetUpscalingMode) == 0x000001, "Wrong size on PhxGameUserSettings_GetUpscalingMode");
static_assert(offsetof(PhxGameUserSettings_GetUpscalingMode, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetUpscalingMode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetUserScreenResolution
// 0x000C (0x000C - 0x0000)
struct PhxGameUserSettings_GetUserScreenResolution final
{
public:
	EWindowMode                                   InWindowMode;                                      // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FIntPoint                              ReturnValue;                                       // 0x0004(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetUserScreenResolution) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetUserScreenResolution");
static_assert(sizeof(PhxGameUserSettings_GetUserScreenResolution) == 0x00000C, "Wrong size on PhxGameUserSettings_GetUserScreenResolution");
static_assert(offsetof(PhxGameUserSettings_GetUserScreenResolution, InWindowMode) == 0x000000, "Member 'PhxGameUserSettings_GetUserScreenResolution::InWindowMode' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_GetUserScreenResolution, ReturnValue) == 0x000004, "Member 'PhxGameUserSettings_GetUserScreenResolution::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetVolumetricsQuality
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetVolumetricsQuality final
{
public:
	EGraphicsQuality                              ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetVolumetricsQuality) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetVolumetricsQuality");
static_assert(sizeof(PhxGameUserSettings_GetVolumetricsQuality) == 0x000001, "Wrong size on PhxGameUserSettings_GetVolumetricsQuality");
static_assert(offsetof(PhxGameUserSettings_GetVolumetricsQuality, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetVolumetricsQuality::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetWantedHDROutput
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_GetWantedHDROutput final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetWantedHDROutput) == 0x000001, "Wrong alignment on PhxGameUserSettings_GetWantedHDROutput");
static_assert(sizeof(PhxGameUserSettings_GetWantedHDROutput) == 0x000001, "Wrong size on PhxGameUserSettings_GetWantedHDROutput");
static_assert(offsetof(PhxGameUserSettings_GetWantedHDROutput, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetWantedHDROutput::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.GetWantedPeakNits
// 0x0004 (0x0004 - 0x0000)
struct PhxGameUserSettings_GetWantedPeakNits final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_GetWantedPeakNits) == 0x000004, "Wrong alignment on PhxGameUserSettings_GetWantedPeakNits");
static_assert(sizeof(PhxGameUserSettings_GetWantedPeakNits) == 0x000004, "Wrong size on PhxGameUserSettings_GetWantedPeakNits");
static_assert(offsetof(PhxGameUserSettings_GetWantedPeakNits, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_GetWantedPeakNits::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsCameraShakeReduced
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsCameraShakeReduced final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsCameraShakeReduced) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsCameraShakeReduced");
static_assert(sizeof(PhxGameUserSettings_IsCameraShakeReduced) == 0x000001, "Wrong size on PhxGameUserSettings_IsCameraShakeReduced");
static_assert(offsetof(PhxGameUserSettings_IsCameraShakeReduced, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsCameraShakeReduced::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsCameraTwistReduced
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsCameraTwistReduced final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsCameraTwistReduced) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsCameraTwistReduced");
static_assert(sizeof(PhxGameUserSettings_IsCameraTwistReduced) == 0x000001, "Wrong size on PhxGameUserSettings_IsCameraTwistReduced");
static_assert(offsetof(PhxGameUserSettings_IsCameraTwistReduced, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsCameraTwistReduced::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsConsolePerformanceModeEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsConsolePerformanceModeEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsConsolePerformanceModeEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsConsolePerformanceModeEnabled");
static_assert(sizeof(PhxGameUserSettings_IsConsolePerformanceModeEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsConsolePerformanceModeEnabled");
static_assert(offsetof(PhxGameUserSettings_IsConsolePerformanceModeEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsConsolePerformanceModeEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsDepthOfFieldEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsDepthOfFieldEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsDepthOfFieldEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsDepthOfFieldEnabled");
static_assert(sizeof(PhxGameUserSettings_IsDepthOfFieldEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsDepthOfFieldEnabled");
static_assert(offsetof(PhxGameUserSettings_IsDepthOfFieldEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsDepthOfFieldEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsDialogueEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsDialogueEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsDialogueEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsDialogueEnabled");
static_assert(sizeof(PhxGameUserSettings_IsDialogueEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsDialogueEnabled");
static_assert(offsetof(PhxGameUserSettings_IsDialogueEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsDialogueEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsFilmGrainEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsFilmGrainEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsFilmGrainEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsFilmGrainEnabled");
static_assert(sizeof(PhxGameUserSettings_IsFilmGrainEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsFilmGrainEnabled");
static_assert(offsetof(PhxGameUserSettings_IsFilmGrainEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsFilmGrainEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsFirstOnlineRun
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsFirstOnlineRun final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsFirstOnlineRun) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsFirstOnlineRun");
static_assert(sizeof(PhxGameUserSettings_IsFirstOnlineRun) == 0x000001, "Wrong size on PhxGameUserSettings_IsFirstOnlineRun");
static_assert(offsetof(PhxGameUserSettings_IsFirstOnlineRun, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsFirstOnlineRun::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsFirstRun
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsFirstRun final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsFirstRun) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsFirstRun");
static_assert(sizeof(PhxGameUserSettings_IsFirstRun) == 0x000001, "Wrong size on PhxGameUserSettings_IsFirstRun");
static_assert(offsetof(PhxGameUserSettings_IsFirstRun, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsFirstRun::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsGraphicsPreset
// 0x0002 (0x0002 - 0x0000)
struct PhxGameUserSettings_IsGraphicsPreset final
{
public:
	EPhxGraphicsPreset                            PresetLevel;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0001(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsGraphicsPreset) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsGraphicsPreset");
static_assert(sizeof(PhxGameUserSettings_IsGraphicsPreset) == 0x000002, "Wrong size on PhxGameUserSettings_IsGraphicsPreset");
static_assert(offsetof(PhxGameUserSettings_IsGraphicsPreset, PresetLevel) == 0x000000, "Member 'PhxGameUserSettings_IsGraphicsPreset::PresetLevel' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_IsGraphicsPreset, ReturnValue) == 0x000001, "Member 'PhxGameUserSettings_IsGraphicsPreset::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsLeftHandBiasedController
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsLeftHandBiasedController final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsLeftHandBiasedController) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsLeftHandBiasedController");
static_assert(sizeof(PhxGameUserSettings_IsLeftHandBiasedController) == 0x000001, "Wrong size on PhxGameUserSettings_IsLeftHandBiasedController");
static_assert(offsetof(PhxGameUserSettings_IsLeftHandBiasedController, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsLeftHandBiasedController::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsMotionBlurEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsMotionBlurEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsMotionBlurEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsMotionBlurEnabled");
static_assert(sizeof(PhxGameUserSettings_IsMotionBlurEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsMotionBlurEnabled");
static_assert(offsetof(PhxGameUserSettings_IsMotionBlurEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsMotionBlurEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsMusicEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsMusicEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsMusicEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsMusicEnabled");
static_assert(sizeof(PhxGameUserSettings_IsMusicEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsMusicEnabled");
static_assert(offsetof(PhxGameUserSettings_IsMusicEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsMusicEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsPhysicalRefractionEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsPhysicalRefractionEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsPhysicalRefractionEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsPhysicalRefractionEnabled");
static_assert(sizeof(PhxGameUserSettings_IsPhysicalRefractionEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsPhysicalRefractionEnabled");
static_assert(offsetof(PhxGameUserSettings_IsPhysicalRefractionEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsPhysicalRefractionEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsRadioBanterChannelSupported
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsRadioBanterChannelSupported final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsRadioBanterChannelSupported) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsRadioBanterChannelSupported");
static_assert(sizeof(PhxGameUserSettings_IsRadioBanterChannelSupported) == 0x000001, "Wrong size on PhxGameUserSettings_IsRadioBanterChannelSupported");
static_assert(offsetof(PhxGameUserSettings_IsRadioBanterChannelSupported, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsRadioBanterChannelSupported::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsRaytracedShadowsEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsRaytracedShadowsEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsRaytracedShadowsEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsRaytracedShadowsEnabled");
static_assert(sizeof(PhxGameUserSettings_IsRaytracedShadowsEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsRaytracedShadowsEnabled");
static_assert(offsetof(PhxGameUserSettings_IsRaytracedShadowsEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsRaytracedShadowsEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsRaytracedTransmissionEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsRaytracedTransmissionEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsRaytracedTransmissionEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsRaytracedTransmissionEnabled");
static_assert(sizeof(PhxGameUserSettings_IsRaytracedTransmissionEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsRaytracedTransmissionEnabled");
static_assert(offsetof(PhxGameUserSettings_IsRaytracedTransmissionEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsRaytracedTransmissionEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsRumbleEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsRumbleEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsRumbleEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsRumbleEnabled");
static_assert(sizeof(PhxGameUserSettings_IsRumbleEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsRumbleEnabled");
static_assert(offsetof(PhxGameUserSettings_IsRumbleEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsRumbleEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsScreenSpaceReflectionsEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsScreenSpaceReflectionsEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsScreenSpaceReflectionsEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsScreenSpaceReflectionsEnabled");
static_assert(sizeof(PhxGameUserSettings_IsScreenSpaceReflectionsEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsScreenSpaceReflectionsEnabled");
static_assert(offsetof(PhxGameUserSettings_IsScreenSpaceReflectionsEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsScreenSpaceReflectionsEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsSFXEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsSFXEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsSFXEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsSFXEnabled");
static_assert(sizeof(PhxGameUserSettings_IsSFXEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsSFXEnabled");
static_assert(offsetof(PhxGameUserSettings_IsSFXEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsSFXEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsSubsurfaceScatteringEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsSubsurfaceScatteringEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsSubsurfaceScatteringEnabled) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsSubsurfaceScatteringEnabled");
static_assert(sizeof(PhxGameUserSettings_IsSubsurfaceScatteringEnabled) == 0x000001, "Wrong size on PhxGameUserSettings_IsSubsurfaceScatteringEnabled");
static_assert(offsetof(PhxGameUserSettings_IsSubsurfaceScatteringEnabled, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsSubsurfaceScatteringEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsTutorialTagActivated
// 0x000C (0x000C - 0x0000)
struct PhxGameUserSettings_IsTutorialTagActivated final
{
public:
	struct FGameplayTag                           TutorialTag;                                       // 0x0000(0x0008)(Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGameUserSettings_IsTutorialTagActivated) == 0x000004, "Wrong alignment on PhxGameUserSettings_IsTutorialTagActivated");
static_assert(sizeof(PhxGameUserSettings_IsTutorialTagActivated) == 0x00000C, "Wrong size on PhxGameUserSettings_IsTutorialTagActivated");
static_assert(offsetof(PhxGameUserSettings_IsTutorialTagActivated, TutorialTag) == 0x000000, "Member 'PhxGameUserSettings_IsTutorialTagActivated::TutorialTag' has a wrong offset!");
static_assert(offsetof(PhxGameUserSettings_IsTutorialTagActivated, ReturnValue) == 0x000008, "Member 'PhxGameUserSettings_IsTutorialTagActivated::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.IsUsingHDR
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_IsUsingHDR final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_IsUsingHDR) == 0x000001, "Wrong alignment on PhxGameUserSettings_IsUsingHDR");
static_assert(sizeof(PhxGameUserSettings_IsUsingHDR) == 0x000001, "Wrong size on PhxGameUserSettings_IsUsingHDR");
static_assert(offsetof(PhxGameUserSettings_IsUsingHDR, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_IsUsingHDR::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.LocalizationContentManagerSupportsInGameInstall
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_LocalizationContentManagerSupportsInGameInstall final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_LocalizationContentManagerSupportsInGameInstall) == 0x000001, "Wrong alignment on PhxGameUserSettings_LocalizationContentManagerSupportsInGameInstall");
static_assert(sizeof(PhxGameUserSettings_LocalizationContentManagerSupportsInGameInstall) == 0x000001, "Wrong size on PhxGameUserSettings_LocalizationContentManagerSupportsInGameInstall");
static_assert(offsetof(PhxGameUserSettings_LocalizationContentManagerSupportsInGameInstall, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_LocalizationContentManagerSupportsInGameInstall::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.LocalizationContentManagerUsesEpicGamesStore
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_LocalizationContentManagerUsesEpicGamesStore final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_LocalizationContentManagerUsesEpicGamesStore) == 0x000001, "Wrong alignment on PhxGameUserSettings_LocalizationContentManagerUsesEpicGamesStore");
static_assert(sizeof(PhxGameUserSettings_LocalizationContentManagerUsesEpicGamesStore) == 0x000001, "Wrong size on PhxGameUserSettings_LocalizationContentManagerUsesEpicGamesStore");
static_assert(offsetof(PhxGameUserSettings_LocalizationContentManagerUsesEpicGamesStore, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_LocalizationContentManagerUsesEpicGamesStore::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.LocalizationContentManagerUsesSteam
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_LocalizationContentManagerUsesSteam final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_LocalizationContentManagerUsesSteam) == 0x000001, "Wrong alignment on PhxGameUserSettings_LocalizationContentManagerUsesSteam");
static_assert(sizeof(PhxGameUserSettings_LocalizationContentManagerUsesSteam) == 0x000001, "Wrong size on PhxGameUserSettings_LocalizationContentManagerUsesSteam");
static_assert(offsetof(PhxGameUserSettings_LocalizationContentManagerUsesSteam, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_LocalizationContentManagerUsesSteam::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SeenMenuReaderPrompt
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SeenMenuReaderPrompt final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SeenMenuReaderPrompt) == 0x000001, "Wrong alignment on PhxGameUserSettings_SeenMenuReaderPrompt");
static_assert(sizeof(PhxGameUserSettings_SeenMenuReaderPrompt) == 0x000001, "Wrong size on PhxGameUserSettings_SeenMenuReaderPrompt");
static_assert(offsetof(PhxGameUserSettings_SeenMenuReaderPrompt, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_SeenMenuReaderPrompt::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.SupportsConsolePerformanceMode
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_SupportsConsolePerformanceMode final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_SupportsConsolePerformanceMode) == 0x000001, "Wrong alignment on PhxGameUserSettings_SupportsConsolePerformanceMode");
static_assert(sizeof(PhxGameUserSettings_SupportsConsolePerformanceMode) == 0x000001, "Wrong size on PhxGameUserSettings_SupportsConsolePerformanceMode");
static_assert(offsetof(PhxGameUserSettings_SupportsConsolePerformanceMode, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_SupportsConsolePerformanceMode::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.WasDismembermentUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_WasDismembermentUnlockDisplayed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_WasDismembermentUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_WasDismembermentUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_WasDismembermentUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_WasDismembermentUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_WasDismembermentUnlockDisplayed, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_WasDismembermentUnlockDisplayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.WasGoldSkinUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_WasGoldSkinUnlockDisplayed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_WasGoldSkinUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_WasGoldSkinUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_WasGoldSkinUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_WasGoldSkinUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_WasGoldSkinUnlockDisplayed, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_WasGoldSkinUnlockDisplayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.WasHardcoreNGPlusUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_WasHardcoreNGPlusUnlockDisplayed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_WasHardcoreNGPlusUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_WasHardcoreNGPlusUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_WasHardcoreNGPlusUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_WasHardcoreNGPlusUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_WasHardcoreNGPlusUnlockDisplayed, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_WasHardcoreNGPlusUnlockDisplayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.WasHardcoreUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_WasHardcoreUnlockDisplayed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_WasHardcoreUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_WasHardcoreUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_WasHardcoreUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_WasHardcoreUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_WasHardcoreUnlockDisplayed, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_WasHardcoreUnlockDisplayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.WasHazmatUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_WasHazmatUnlockDisplayed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_WasHazmatUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_WasHazmatUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_WasHazmatUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_WasHazmatUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_WasHazmatUnlockDisplayed, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_WasHazmatUnlockDisplayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.WasHordeUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_WasHordeUnlockDisplayed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_WasHordeUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_WasHordeUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_WasHordeUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_WasHordeUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_WasHordeUnlockDisplayed, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_WasHordeUnlockDisplayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.WasStoryDLCUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_WasStoryDLCUnlockDisplayed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_WasStoryDLCUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_WasStoryDLCUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_WasStoryDLCUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_WasStoryDLCUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_WasStoryDLCUnlockDisplayed, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_WasStoryDLCUnlockDisplayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.WasSurvivalNGPlusUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_WasSurvivalNGPlusUnlockDisplayed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_WasSurvivalNGPlusUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_WasSurvivalNGPlusUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_WasSurvivalNGPlusUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_WasSurvivalNGPlusUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_WasSurvivalNGPlusUnlockDisplayed, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_WasSurvivalNGPlusUnlockDisplayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGameUserSettings.WasSurvivalUnlockDisplayed
// 0x0001 (0x0001 - 0x0000)
struct PhxGameUserSettings_WasSurvivalUnlockDisplayed final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGameUserSettings_WasSurvivalUnlockDisplayed) == 0x000001, "Wrong alignment on PhxGameUserSettings_WasSurvivalUnlockDisplayed");
static_assert(sizeof(PhxGameUserSettings_WasSurvivalUnlockDisplayed) == 0x000001, "Wrong size on PhxGameUserSettings_WasSurvivalUnlockDisplayed");
static_assert(offsetof(PhxGameUserSettings_WasSurvivalUnlockDisplayed, ReturnValue) == 0x000000, "Member 'PhxGameUserSettings_WasSurvivalUnlockDisplayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGRPInteractionData.GetLaunchSpeed
// 0x0008 (0x0008 - 0x0000)
struct PhxGRPInteractionData_GetLaunchSpeed final
{
public:
	EGRPLaunchLevel                               LaunchLevel;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGRPInteractionData_GetLaunchSpeed) == 0x000004, "Wrong alignment on PhxGRPInteractionData_GetLaunchSpeed");
static_assert(sizeof(PhxGRPInteractionData_GetLaunchSpeed) == 0x000008, "Wrong size on PhxGRPInteractionData_GetLaunchSpeed");
static_assert(offsetof(PhxGRPInteractionData_GetLaunchSpeed, LaunchLevel) == 0x000000, "Member 'PhxGRPInteractionData_GetLaunchSpeed::LaunchLevel' has a wrong offset!");
static_assert(offsetof(PhxGRPInteractionData_GetLaunchSpeed, ReturnValue) == 0x000004, "Member 'PhxGRPInteractionData_GetLaunchSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGRPInteractionData.GetPropCollisionDamageValue
// 0x0008 (0x0008 - 0x0000)
struct PhxGRPInteractionData_GetPropCollisionDamageValue final
{
public:
	EGRPLaunchLevel                               LaunchLevel;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGRPInteractionData_GetPropCollisionDamageValue) == 0x000004, "Wrong alignment on PhxGRPInteractionData_GetPropCollisionDamageValue");
static_assert(sizeof(PhxGRPInteractionData_GetPropCollisionDamageValue) == 0x000008, "Wrong size on PhxGRPInteractionData_GetPropCollisionDamageValue");
static_assert(offsetof(PhxGRPInteractionData_GetPropCollisionDamageValue, LaunchLevel) == 0x000000, "Member 'PhxGRPInteractionData_GetPropCollisionDamageValue::LaunchLevel' has a wrong offset!");
static_assert(offsetof(PhxGRPInteractionData_GetPropCollisionDamageValue, ReturnValue) == 0x000004, "Member 'PhxGRPInteractionData_GetPropCollisionDamageValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxGRPPhysicsProp.HandlePropHit
// 0x00B0 (0x00B0 - 0x0000)
struct PhxGRPPhysicsProp_HandlePropHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxGRPPhysicsProp_HandlePropHit) == 0x000008, "Wrong alignment on PhxGRPPhysicsProp_HandlePropHit");
static_assert(sizeof(PhxGRPPhysicsProp_HandlePropHit) == 0x0000B0, "Wrong size on PhxGRPPhysicsProp_HandlePropHit");
static_assert(offsetof(PhxGRPPhysicsProp_HandlePropHit, HitComp) == 0x000000, "Member 'PhxGRPPhysicsProp_HandlePropHit::HitComp' has a wrong offset!");
static_assert(offsetof(PhxGRPPhysicsProp_HandlePropHit, OtherActor) == 0x000008, "Member 'PhxGRPPhysicsProp_HandlePropHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxGRPPhysicsProp_HandlePropHit, OtherComp) == 0x000010, "Member 'PhxGRPPhysicsProp_HandlePropHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxGRPPhysicsProp_HandlePropHit, NormalImpulse) == 0x000018, "Member 'PhxGRPPhysicsProp_HandlePropHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxGRPPhysicsProp_HandlePropHit, Hit) == 0x000024, "Member 'PhxGRPPhysicsProp_HandlePropHit::Hit' has a wrong offset!");

// Function Phoenix.PhxGRPPhysicsProp.OnGRPOverlappedHitReceiver
// 0x0008 (0x0008 - 0x0000)
struct PhxGRPPhysicsProp_OnGRPOverlappedHitReceiver final
{
public:
	class APhxCharacter*                          OverlappedCharacter;                               // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGRPPhysicsProp_OnGRPOverlappedHitReceiver) == 0x000008, "Wrong alignment on PhxGRPPhysicsProp_OnGRPOverlappedHitReceiver");
static_assert(sizeof(PhxGRPPhysicsProp_OnGRPOverlappedHitReceiver) == 0x000008, "Wrong size on PhxGRPPhysicsProp_OnGRPOverlappedHitReceiver");
static_assert(offsetof(PhxGRPPhysicsProp_OnGRPOverlappedHitReceiver, OverlappedCharacter) == 0x000000, "Member 'PhxGRPPhysicsProp_OnGRPOverlappedHitReceiver::OverlappedCharacter' has a wrong offset!");

// Function Phoenix.PhxGRPPhysicsProp.OnLootDropBoxDamageTaken
// 0x0008 (0x0008 - 0x0000)
struct PhxGRPPhysicsProp_OnLootDropBoxDamageTaken final
{
public:
	class AActor*                                 InstigatorActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGRPPhysicsProp_OnLootDropBoxDamageTaken) == 0x000008, "Wrong alignment on PhxGRPPhysicsProp_OnLootDropBoxDamageTaken");
static_assert(sizeof(PhxGRPPhysicsProp_OnLootDropBoxDamageTaken) == 0x000008, "Wrong size on PhxGRPPhysicsProp_OnLootDropBoxDamageTaken");
static_assert(offsetof(PhxGRPPhysicsProp_OnLootDropBoxDamageTaken, InstigatorActor) == 0x000000, "Member 'PhxGRPPhysicsProp_OnLootDropBoxDamageTaken::InstigatorActor' has a wrong offset!");

// Function Phoenix.PhxGRPProxyActor.SetGRPEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxGRPProxyActor_SetGRPEnabled final
{
public:
	bool                                          bInGRPEnabled;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxGRPProxyActor_SetGRPEnabled) == 0x000001, "Wrong alignment on PhxGRPProxyActor_SetGRPEnabled");
static_assert(sizeof(PhxGRPProxyActor_SetGRPEnabled) == 0x000001, "Wrong size on PhxGRPProxyActor_SetGRPEnabled");
static_assert(offsetof(PhxGRPProxyActor_SetGRPEnabled, bInGRPEnabled) == 0x000000, "Member 'PhxGRPProxyActor_SetGRPEnabled::bInGRPEnabled' has a wrong offset!");

// Function Phoenix.PhxWarnIncomingAttackModifier.OnAnyAttackStarted
// 0x0010 (0x0010 - 0x0000)
struct PhxWarnIncomingAttackModifier_OnAnyAttackStarted final
{
public:
	class APhxCharacter*                          Attacker;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAttackState*                           AttackState;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWarnIncomingAttackModifier_OnAnyAttackStarted) == 0x000008, "Wrong alignment on PhxWarnIncomingAttackModifier_OnAnyAttackStarted");
static_assert(sizeof(PhxWarnIncomingAttackModifier_OnAnyAttackStarted) == 0x000010, "Wrong size on PhxWarnIncomingAttackModifier_OnAnyAttackStarted");
static_assert(offsetof(PhxWarnIncomingAttackModifier_OnAnyAttackStarted, Attacker) == 0x000000, "Member 'PhxWarnIncomingAttackModifier_OnAnyAttackStarted::Attacker' has a wrong offset!");
static_assert(offsetof(PhxWarnIncomingAttackModifier_OnAnyAttackStarted, AttackState) == 0x000008, "Member 'PhxWarnIncomingAttackModifier_OnAnyAttackStarted::AttackState' has a wrong offset!");

// Function Phoenix.PhxWorldMarker.HandleGamePaused
// 0x0001 (0x0001 - 0x0000)
struct PhxWorldMarker_HandleGamePaused final
{
public:
	bool                                          bPaused;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldMarker_HandleGamePaused) == 0x000001, "Wrong alignment on PhxWorldMarker_HandleGamePaused");
static_assert(sizeof(PhxWorldMarker_HandleGamePaused) == 0x000001, "Wrong size on PhxWorldMarker_HandleGamePaused");
static_assert(offsetof(PhxWorldMarker_HandleGamePaused, bPaused) == 0x000000, "Member 'PhxWorldMarker_HandleGamePaused::bPaused' has a wrong offset!");

// Function Phoenix.PhxWorldMarker.SetTimeout
// 0x0004 (0x0004 - 0x0000)
struct PhxWorldMarker_SetTimeout final
{
public:
	float                                         InTimeout;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldMarker_SetTimeout) == 0x000004, "Wrong alignment on PhxWorldMarker_SetTimeout");
static_assert(sizeof(PhxWorldMarker_SetTimeout) == 0x000004, "Wrong size on PhxWorldMarker_SetTimeout");
static_assert(offsetof(PhxWorldMarker_SetTimeout, InTimeout) == 0x000000, "Member 'PhxWorldMarker_SetTimeout::InTimeout' has a wrong offset!");

// Function Phoenix.PhxWorldMarker.GetTargetActor
// 0x0008 (0x0008 - 0x0000)
struct PhxWorldMarker_GetTargetActor final
{
public:
	const class AActor*                           ReturnValue;                                       // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldMarker_GetTargetActor) == 0x000008, "Wrong alignment on PhxWorldMarker_GetTargetActor");
static_assert(sizeof(PhxWorldMarker_GetTargetActor) == 0x000008, "Wrong size on PhxWorldMarker_GetTargetActor");
static_assert(offsetof(PhxWorldMarker_GetTargetActor, ReturnValue) == 0x000000, "Member 'PhxWorldMarker_GetTargetActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputKeyToAction.LookupInputKey
// 0x0010 (0x0010 - 0x0000)
struct PhxInputKeyToAction_LookupInputKey final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AxisScale;                                         // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxInputKeys                                 ReturnValue;                                       // 0x000C(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxInputKeyToAction_LookupInputKey) == 0x000004, "Wrong alignment on PhxInputKeyToAction_LookupInputKey");
static_assert(sizeof(PhxInputKeyToAction_LookupInputKey) == 0x000010, "Wrong size on PhxInputKeyToAction_LookupInputKey");
static_assert(offsetof(PhxInputKeyToAction_LookupInputKey, ActionName) == 0x000000, "Member 'PhxInputKeyToAction_LookupInputKey::ActionName' has a wrong offset!");
static_assert(offsetof(PhxInputKeyToAction_LookupInputKey, AxisScale) == 0x000008, "Member 'PhxInputKeyToAction_LookupInputKey::AxisScale' has a wrong offset!");
static_assert(offsetof(PhxInputKeyToAction_LookupInputKey, ReturnValue) == 0x00000C, "Member 'PhxInputKeyToAction_LookupInputKey::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputKeyToAction.RebuildInputIconTable
// 0x0008 (0x0008 - 0x0000)
struct PhxInputKeyToAction_RebuildInputIconTable final
{
public:
	const class APhxPlayerController*             PlayerController;                                  // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputKeyToAction_RebuildInputIconTable) == 0x000008, "Wrong alignment on PhxInputKeyToAction_RebuildInputIconTable");
static_assert(sizeof(PhxInputKeyToAction_RebuildInputIconTable) == 0x000008, "Wrong size on PhxInputKeyToAction_RebuildInputIconTable");
static_assert(offsetof(PhxInputKeyToAction_RebuildInputIconTable, PlayerController) == 0x000000, "Member 'PhxInputKeyToAction_RebuildInputIconTable::PlayerController' has a wrong offset!");

// Function Phoenix.PhxInputKeyToAction.GetUIInputKeyAction
// 0x0070 (0x0070 - 0x0000)
struct PhxInputKeyToAction_GetUIInputKeyAction final
{
public:
	EPhxInputKeys                                 InKey;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FActionMapKey                          ReturnValue;                                       // 0x0008(0x0068)(ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputKeyToAction_GetUIInputKeyAction) == 0x000008, "Wrong alignment on PhxInputKeyToAction_GetUIInputKeyAction");
static_assert(sizeof(PhxInputKeyToAction_GetUIInputKeyAction) == 0x000070, "Wrong size on PhxInputKeyToAction_GetUIInputKeyAction");
static_assert(offsetof(PhxInputKeyToAction_GetUIInputKeyAction, InKey) == 0x000000, "Member 'PhxInputKeyToAction_GetUIInputKeyAction::InKey' has a wrong offset!");
static_assert(offsetof(PhxInputKeyToAction_GetUIInputKeyAction, ReturnValue) == 0x000008, "Member 'PhxInputKeyToAction_GetUIInputKeyAction::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputAxisMappingData.GetInputKeyList
// 0x0018 (0x0018 - 0x0000)
struct PhxInputAxisMappingData_GetInputKeyList final
{
public:
	EPhxInputType                                 InType;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InScale;                                           // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FKey>                           ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputAxisMappingData_GetInputKeyList) == 0x000008, "Wrong alignment on PhxInputAxisMappingData_GetInputKeyList");
static_assert(sizeof(PhxInputAxisMappingData_GetInputKeyList) == 0x000018, "Wrong size on PhxInputAxisMappingData_GetInputKeyList");
static_assert(offsetof(PhxInputAxisMappingData_GetInputKeyList, InType) == 0x000000, "Member 'PhxInputAxisMappingData_GetInputKeyList::InType' has a wrong offset!");
static_assert(offsetof(PhxInputAxisMappingData_GetInputKeyList, InScale) == 0x000004, "Member 'PhxInputAxisMappingData_GetInputKeyList::InScale' has a wrong offset!");
static_assert(offsetof(PhxInputAxisMappingData_GetInputKeyList, ReturnValue) == 0x000008, "Member 'PhxInputAxisMappingData_GetInputKeyList::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputAxisMappingData.GetInputKeyForUI
// 0x0020 (0x0020 - 0x0000)
struct PhxInputAxisMappingData_GetInputKeyForUI final
{
public:
	EPhxInputType                                 InType;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InScale;                                           // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FKey                                   ReturnValue;                                       // 0x0008(0x0018)(Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputAxisMappingData_GetInputKeyForUI) == 0x000008, "Wrong alignment on PhxInputAxisMappingData_GetInputKeyForUI");
static_assert(sizeof(PhxInputAxisMappingData_GetInputKeyForUI) == 0x000020, "Wrong size on PhxInputAxisMappingData_GetInputKeyForUI");
static_assert(offsetof(PhxInputAxisMappingData_GetInputKeyForUI, InType) == 0x000000, "Member 'PhxInputAxisMappingData_GetInputKeyForUI::InType' has a wrong offset!");
static_assert(offsetof(PhxInputAxisMappingData_GetInputKeyForUI, InScale) == 0x000004, "Member 'PhxInputAxisMappingData_GetInputKeyForUI::InScale' has a wrong offset!");
static_assert(offsetof(PhxInputAxisMappingData_GetInputKeyForUI, ReturnValue) == 0x000008, "Member 'PhxInputAxisMappingData_GetInputKeyForUI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputAxisMappingData.IsInputType
// 0x0020 (0x0020 - 0x0000)
struct PhxInputAxisMappingData_IsInputType final
{
public:
	struct FKey                                   Key;                                               // 0x0000(0x0018)(ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxInputType                                 InType;                                            // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0019(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1A[0x6];                                       // 0x001A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxInputAxisMappingData_IsInputType) == 0x000008, "Wrong alignment on PhxInputAxisMappingData_IsInputType");
static_assert(sizeof(PhxInputAxisMappingData_IsInputType) == 0x000020, "Wrong size on PhxInputAxisMappingData_IsInputType");
static_assert(offsetof(PhxInputAxisMappingData_IsInputType, Key) == 0x000000, "Member 'PhxInputAxisMappingData_IsInputType::Key' has a wrong offset!");
static_assert(offsetof(PhxInputAxisMappingData_IsInputType, InType) == 0x000018, "Member 'PhxInputAxisMappingData_IsInputType::InType' has a wrong offset!");
static_assert(offsetof(PhxInputAxisMappingData_IsInputType, ReturnValue) == 0x000019, "Member 'PhxInputAxisMappingData_IsInputType::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetFilteredMappingForAction
// 0x0018 (0x0018 - 0x0000)
struct PhxInputMappingSettings_GetFilteredMappingForAction final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxInputType                                 InType;                                            // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxInputActionMappingData*             ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetFilteredMappingForAction) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetFilteredMappingForAction");
static_assert(sizeof(PhxInputMappingSettings_GetFilteredMappingForAction) == 0x000018, "Wrong size on PhxInputMappingSettings_GetFilteredMappingForAction");
static_assert(offsetof(PhxInputMappingSettings_GetFilteredMappingForAction, ActionName) == 0x000000, "Member 'PhxInputMappingSettings_GetFilteredMappingForAction::ActionName' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetFilteredMappingForAction, InType) == 0x000008, "Member 'PhxInputMappingSettings_GetFilteredMappingForAction::InType' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetFilteredMappingForAction, ReturnValue) == 0x000010, "Member 'PhxInputMappingSettings_GetFilteredMappingForAction::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetFilteredMappingForAxis
// 0x0018 (0x0018 - 0x0000)
struct PhxInputMappingSettings_GetFilteredMappingForAxis final
{
public:
	class FName                                   AxisName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AxisScale;                                         // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxInputType                                 InType;                                            // 0x000C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxInputAxisMappingData*               ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetFilteredMappingForAxis) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetFilteredMappingForAxis");
static_assert(sizeof(PhxInputMappingSettings_GetFilteredMappingForAxis) == 0x000018, "Wrong size on PhxInputMappingSettings_GetFilteredMappingForAxis");
static_assert(offsetof(PhxInputMappingSettings_GetFilteredMappingForAxis, AxisName) == 0x000000, "Member 'PhxInputMappingSettings_GetFilteredMappingForAxis::AxisName' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetFilteredMappingForAxis, AxisScale) == 0x000008, "Member 'PhxInputMappingSettings_GetFilteredMappingForAxis::AxisScale' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetFilteredMappingForAxis, InType) == 0x00000C, "Member 'PhxInputMappingSettings_GetFilteredMappingForAxis::InType' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetFilteredMappingForAxis, ReturnValue) == 0x000010, "Member 'PhxInputMappingSettings_GetFilteredMappingForAxis::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetKeyListForAction
// 0x0020 (0x0020 - 0x0000)
struct PhxInputMappingSettings_GetKeyListForAction final
{
public:
	class FName                                   InActionName;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InAxisScale;                                       // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxInputType                                 InFilter;                                          // 0x000C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FKey>                           ReturnValue;                                       // 0x0010(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetKeyListForAction) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetKeyListForAction");
static_assert(sizeof(PhxInputMappingSettings_GetKeyListForAction) == 0x000020, "Wrong size on PhxInputMappingSettings_GetKeyListForAction");
static_assert(offsetof(PhxInputMappingSettings_GetKeyListForAction, InActionName) == 0x000000, "Member 'PhxInputMappingSettings_GetKeyListForAction::InActionName' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetKeyListForAction, InAxisScale) == 0x000008, "Member 'PhxInputMappingSettings_GetKeyListForAction::InAxisScale' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetKeyListForAction, InFilter) == 0x00000C, "Member 'PhxInputMappingSettings_GetKeyListForAction::InFilter' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetKeyListForAction, ReturnValue) == 0x000010, "Member 'PhxInputMappingSettings_GetKeyListForAction::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetRemappableInputMappingForAction
// 0x0010 (0x0010 - 0x0000)
struct PhxInputMappingSettings_GetRemappableInputMappingForAction final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxInputActionMappingData*             ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetRemappableInputMappingForAction) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetRemappableInputMappingForAction");
static_assert(sizeof(PhxInputMappingSettings_GetRemappableInputMappingForAction) == 0x000010, "Wrong size on PhxInputMappingSettings_GetRemappableInputMappingForAction");
static_assert(offsetof(PhxInputMappingSettings_GetRemappableInputMappingForAction, ActionName) == 0x000000, "Member 'PhxInputMappingSettings_GetRemappableInputMappingForAction::ActionName' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetRemappableInputMappingForAction, ReturnValue) == 0x000008, "Member 'PhxInputMappingSettings_GetRemappableInputMappingForAction::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetRemappableInputMappingForAxis
// 0x0010 (0x0010 - 0x0000)
struct PhxInputMappingSettings_GetRemappableInputMappingForAxis final
{
public:
	class FName                                   AxisName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxInputAxisMappingData*               ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetRemappableInputMappingForAxis) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetRemappableInputMappingForAxis");
static_assert(sizeof(PhxInputMappingSettings_GetRemappableInputMappingForAxis) == 0x000010, "Wrong size on PhxInputMappingSettings_GetRemappableInputMappingForAxis");
static_assert(offsetof(PhxInputMappingSettings_GetRemappableInputMappingForAxis, AxisName) == 0x000000, "Member 'PhxInputMappingSettings_GetRemappableInputMappingForAxis::AxisName' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetRemappableInputMappingForAxis, ReturnValue) == 0x000008, "Member 'PhxInputMappingSettings_GetRemappableInputMappingForAxis::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetUILabelForController
// 0x0030 (0x0030 - 0x0000)
struct PhxInputMappingSettings_GetUILabelForController final
{
public:
	struct FKey                                   InKey;                                             // 0x0000(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InScale;                                           // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsAnalog;                                         // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FText>                           ReturnValue;                                       // 0x0020(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetUILabelForController) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetUILabelForController");
static_assert(sizeof(PhxInputMappingSettings_GetUILabelForController) == 0x000030, "Wrong size on PhxInputMappingSettings_GetUILabelForController");
static_assert(offsetof(PhxInputMappingSettings_GetUILabelForController, InKey) == 0x000000, "Member 'PhxInputMappingSettings_GetUILabelForController::InKey' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetUILabelForController, InScale) == 0x000018, "Member 'PhxInputMappingSettings_GetUILabelForController::InScale' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetUILabelForController, bIsAnalog) == 0x00001C, "Member 'PhxInputMappingSettings_GetUILabelForController::bIsAnalog' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetUILabelForController, ReturnValue) == 0x000020, "Member 'PhxInputMappingSettings_GetUILabelForController::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetActionLabelForUI
// 0x0028 (0x0028 - 0x0000)
struct PhxInputMappingSettings_GetActionLabelForUI final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InScale;                                           // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsAnalog;                                         // 0x000C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FText                                   ReturnValue;                                       // 0x0010(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetActionLabelForUI) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetActionLabelForUI");
static_assert(sizeof(PhxInputMappingSettings_GetActionLabelForUI) == 0x000028, "Wrong size on PhxInputMappingSettings_GetActionLabelForUI");
static_assert(offsetof(PhxInputMappingSettings_GetActionLabelForUI, ActionName) == 0x000000, "Member 'PhxInputMappingSettings_GetActionLabelForUI::ActionName' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetActionLabelForUI, InScale) == 0x000008, "Member 'PhxInputMappingSettings_GetActionLabelForUI::InScale' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetActionLabelForUI, bIsAnalog) == 0x00000C, "Member 'PhxInputMappingSettings_GetActionLabelForUI::bIsAnalog' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetActionLabelForUI, ReturnValue) == 0x000010, "Member 'PhxInputMappingSettings_GetActionLabelForUI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetInputMappingForAction
// 0x0010 (0x0010 - 0x0000)
struct PhxInputMappingSettings_GetInputMappingForAction final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxInputActionMappingData*       ReturnValue;                                       // 0x0008(0x0008)(ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetInputMappingForAction) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetInputMappingForAction");
static_assert(sizeof(PhxInputMappingSettings_GetInputMappingForAction) == 0x000010, "Wrong size on PhxInputMappingSettings_GetInputMappingForAction");
static_assert(offsetof(PhxInputMappingSettings_GetInputMappingForAction, ActionName) == 0x000000, "Member 'PhxInputMappingSettings_GetInputMappingForAction::ActionName' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetInputMappingForAction, ReturnValue) == 0x000008, "Member 'PhxInputMappingSettings_GetInputMappingForAction::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetInputMappingForAxis
// 0x0010 (0x0010 - 0x0000)
struct PhxInputMappingSettings_GetInputMappingForAxis final
{
public:
	class FName                                   AxisName;                                          // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxInputAxisMappingData*         ReturnValue;                                       // 0x0008(0x0008)(ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetInputMappingForAxis) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetInputMappingForAxis");
static_assert(sizeof(PhxInputMappingSettings_GetInputMappingForAxis) == 0x000010, "Wrong size on PhxInputMappingSettings_GetInputMappingForAxis");
static_assert(offsetof(PhxInputMappingSettings_GetInputMappingForAxis, AxisName) == 0x000000, "Member 'PhxInputMappingSettings_GetInputMappingForAxis::AxisName' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetInputMappingForAxis, ReturnValue) == 0x000008, "Member 'PhxInputMappingSettings_GetInputMappingForAxis::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.GetKeyForAction
// 0x0028 (0x0028 - 0x0000)
struct PhxInputMappingSettings_GetKeyForAction final
{
public:
	class FName                                   InActionName;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InAxisScale;                                       // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxInputType                                 InFilter;                                          // 0x000C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FKey                                   ReturnValue;                                       // 0x0010(0x0018)(Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInputMappingSettings_GetKeyForAction) == 0x000008, "Wrong alignment on PhxInputMappingSettings_GetKeyForAction");
static_assert(sizeof(PhxInputMappingSettings_GetKeyForAction) == 0x000028, "Wrong size on PhxInputMappingSettings_GetKeyForAction");
static_assert(offsetof(PhxInputMappingSettings_GetKeyForAction, InActionName) == 0x000000, "Member 'PhxInputMappingSettings_GetKeyForAction::InActionName' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetKeyForAction, InAxisScale) == 0x000008, "Member 'PhxInputMappingSettings_GetKeyForAction::InAxisScale' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetKeyForAction, InFilter) == 0x00000C, "Member 'PhxInputMappingSettings_GetKeyForAction::InFilter' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_GetKeyForAction, ReturnValue) == 0x000010, "Member 'PhxInputMappingSettings_GetKeyForAction::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInputMappingSettings.IsKeyMappedForUI
// 0x0020 (0x0020 - 0x0000)
struct PhxInputMappingSettings_IsKeyMappedForUI final
{
public:
	struct FKey                                   InKey;                                             // 0x0000(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxInputMappingSettings_IsKeyMappedForUI) == 0x000008, "Wrong alignment on PhxInputMappingSettings_IsKeyMappedForUI");
static_assert(sizeof(PhxInputMappingSettings_IsKeyMappedForUI) == 0x000020, "Wrong size on PhxInputMappingSettings_IsKeyMappedForUI");
static_assert(offsetof(PhxInputMappingSettings_IsKeyMappedForUI, InKey) == 0x000000, "Member 'PhxInputMappingSettings_IsKeyMappedForUI::InKey' has a wrong offset!");
static_assert(offsetof(PhxInputMappingSettings_IsKeyMappedForUI, ReturnValue) == 0x000018, "Member 'PhxInputMappingSettings_IsKeyMappedForUI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxInteractableLootProp.PlayOpenMontage
// 0x0001 (0x0001 - 0x0000)
struct PhxInteractableLootProp_PlayOpenMontage final
{
public:
	bool                                          bActorRestored;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInteractableLootProp_PlayOpenMontage) == 0x000001, "Wrong alignment on PhxInteractableLootProp_PlayOpenMontage");
static_assert(sizeof(PhxInteractableLootProp_PlayOpenMontage) == 0x000001, "Wrong size on PhxInteractableLootProp_PlayOpenMontage");
static_assert(offsetof(PhxInteractableLootProp_PlayOpenMontage, bActorRestored) == 0x000000, "Member 'PhxInteractableLootProp_PlayOpenMontage::bActorRestored' has a wrong offset!");

// Function Phoenix.PhxInteractableLootProp.PrepareToPlayOpenMontage
// 0x0001 (0x0001 - 0x0000)
struct PhxInteractableLootProp_PrepareToPlayOpenMontage final
{
public:
	bool                                          bActorRestored;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInteractableLootProp_PrepareToPlayOpenMontage) == 0x000001, "Wrong alignment on PhxInteractableLootProp_PrepareToPlayOpenMontage");
static_assert(sizeof(PhxInteractableLootProp_PrepareToPlayOpenMontage) == 0x000001, "Wrong size on PhxInteractableLootProp_PrepareToPlayOpenMontage");
static_assert(offsetof(PhxInteractableLootProp_PrepareToPlayOpenMontage, bActorRestored) == 0x000000, "Member 'PhxInteractableLootProp_PrepareToPlayOpenMontage::bActorRestored' has a wrong offset!");

// Function Phoenix.PhxInteractableManager.OnButtonPromptSizeChanged
// 0x0001 (0x0001 - 0x0000)
struct PhxInteractableManager_OnButtonPromptSizeChanged final
{
public:
	ESDSSize                                      NewSize;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxInteractableManager_OnButtonPromptSizeChanged) == 0x000001, "Wrong alignment on PhxInteractableManager_OnButtonPromptSizeChanged");
static_assert(sizeof(PhxInteractableManager_OnButtonPromptSizeChanged) == 0x000001, "Wrong size on PhxInteractableManager_OnButtonPromptSizeChanged");
static_assert(offsetof(PhxInteractableManager_OnButtonPromptSizeChanged, NewSize) == 0x000000, "Member 'PhxInteractableManager_OnButtonPromptSizeChanged::NewSize' has a wrong offset!");

// Function Phoenix.PhxItemManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxItemManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxItemManager*                        ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxItemManager_Get) == 0x000008, "Wrong alignment on PhxItemManager_Get");
static_assert(sizeof(PhxItemManager_Get) == 0x000010, "Wrong size on PhxItemManager_Get");
static_assert(offsetof(PhxItemManager_Get, WorldContextObject) == 0x000000, "Member 'PhxItemManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxItemManager_Get, ReturnValue) == 0x000008, "Member 'PhxItemManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxItemManager.GetDefaultItemData
// 0x0108 (0x0108 - 0x0000)
struct PhxItemManager_GetDefaultItemData final
{
public:
	class UClass*                                 PickupClass;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FItemData                              ReturnValue;                                       // 0x0008(0x0100)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxItemManager_GetDefaultItemData) == 0x000008, "Wrong alignment on PhxItemManager_GetDefaultItemData");
static_assert(sizeof(PhxItemManager_GetDefaultItemData) == 0x000108, "Wrong size on PhxItemManager_GetDefaultItemData");
static_assert(offsetof(PhxItemManager_GetDefaultItemData, PickupClass) == 0x000000, "Member 'PhxItemManager_GetDefaultItemData::PickupClass' has a wrong offset!");
static_assert(offsetof(PhxItemManager_GetDefaultItemData, ReturnValue) == 0x000008, "Member 'PhxItemManager_GetDefaultItemData::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxItemManager.GetDefaultItemDataFromHandle
// 0x0110 (0x0110 - 0x0000)
struct PhxItemManager_GetDefaultItemDataFromHandle final
{
public:
	struct FDataTableRowHandle                    ItemRowHandle;                                     // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	struct FItemData                              ReturnValue;                                       // 0x0010(0x0100)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxItemManager_GetDefaultItemDataFromHandle) == 0x000008, "Wrong alignment on PhxItemManager_GetDefaultItemDataFromHandle");
static_assert(sizeof(PhxItemManager_GetDefaultItemDataFromHandle) == 0x000110, "Wrong size on PhxItemManager_GetDefaultItemDataFromHandle");
static_assert(offsetof(PhxItemManager_GetDefaultItemDataFromHandle, ItemRowHandle) == 0x000000, "Member 'PhxItemManager_GetDefaultItemDataFromHandle::ItemRowHandle' has a wrong offset!");
static_assert(offsetof(PhxItemManager_GetDefaultItemDataFromHandle, ReturnValue) == 0x000010, "Member 'PhxItemManager_GetDefaultItemDataFromHandle::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxItemManager.GetDefaultItemDataFromSoftClass
// 0x0128 (0x0128 - 0x0000)
struct PhxItemManager_GetDefaultItemDataFromSoftClass final
{
public:
	TSoftClassPtr<class UClass>                   PickupClass;                                       // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FItemData                              ReturnValue;                                       // 0x0028(0x0100)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxItemManager_GetDefaultItemDataFromSoftClass) == 0x000008, "Wrong alignment on PhxItemManager_GetDefaultItemDataFromSoftClass");
static_assert(sizeof(PhxItemManager_GetDefaultItemDataFromSoftClass) == 0x000128, "Wrong size on PhxItemManager_GetDefaultItemDataFromSoftClass");
static_assert(offsetof(PhxItemManager_GetDefaultItemDataFromSoftClass, PickupClass) == 0x000000, "Member 'PhxItemManager_GetDefaultItemDataFromSoftClass::PickupClass' has a wrong offset!");
static_assert(offsetof(PhxItemManager_GetDefaultItemDataFromSoftClass, ReturnValue) == 0x000028, "Member 'PhxItemManager_GetDefaultItemDataFromSoftClass::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxItemManager.GetItemsUnlockedWith
// 0x0118 (0x0118 - 0x0000)
struct PhxItemManager_GetItemsUnlockedWith final
{
public:
	struct FItemData                              Item;                                              // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	TArray<struct FItemData>                      OutItems;                                          // 0x0100(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0110(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_111[0x7];                                      // 0x0111(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxItemManager_GetItemsUnlockedWith) == 0x000008, "Wrong alignment on PhxItemManager_GetItemsUnlockedWith");
static_assert(sizeof(PhxItemManager_GetItemsUnlockedWith) == 0x000118, "Wrong size on PhxItemManager_GetItemsUnlockedWith");
static_assert(offsetof(PhxItemManager_GetItemsUnlockedWith, Item) == 0x000000, "Member 'PhxItemManager_GetItemsUnlockedWith::Item' has a wrong offset!");
static_assert(offsetof(PhxItemManager_GetItemsUnlockedWith, OutItems) == 0x000100, "Member 'PhxItemManager_GetItemsUnlockedWith::OutItems' has a wrong offset!");
static_assert(offsetof(PhxItemManager_GetItemsUnlockedWith, ReturnValue) == 0x000110, "Member 'PhxItemManager_GetItemsUnlockedWith::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxKeyToControllerKey.GetKeyIcon
// 0x0020 (0x0020 - 0x0000)
struct PhxKeyToControllerKey_GetKeyIcon final
{
public:
	struct FKey                                   InKey;                                             // 0x0000(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxControllerKeys                            ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxKeyToControllerKey_GetKeyIcon) == 0x000008, "Wrong alignment on PhxKeyToControllerKey_GetKeyIcon");
static_assert(sizeof(PhxKeyToControllerKey_GetKeyIcon) == 0x000020, "Wrong size on PhxKeyToControllerKey_GetKeyIcon");
static_assert(offsetof(PhxKeyToControllerKey_GetKeyIcon, InKey) == 0x000000, "Member 'PhxKeyToControllerKey_GetKeyIcon::InKey' has a wrong offset!");
static_assert(offsetof(PhxKeyToControllerKey_GetKeyIcon, ReturnValue) == 0x000018, "Member 'PhxKeyToControllerKey_GetKeyIcon::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelPacingMeterManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxLevelPacingMeterManager*            ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterManager_Get) == 0x000008, "Wrong alignment on PhxLevelPacingMeterManager_Get");
static_assert(sizeof(PhxLevelPacingMeterManager_Get) == 0x000010, "Wrong size on PhxLevelPacingMeterManager_Get");
static_assert(offsetof(PhxLevelPacingMeterManager_Get, WorldContextObject) == 0x000000, "Member 'PhxLevelPacingMeterManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxLevelPacingMeterManager_Get, ReturnValue) == 0x000008, "Member 'PhxLevelPacingMeterManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.OnCheckpointReached
// 0x0008 (0x0008 - 0x0000)
struct PhxLevelPacingMeterManager_OnCheckpointReached final
{
public:
	class ACheckpoint*                            Checkpoint;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterManager_OnCheckpointReached) == 0x000008, "Wrong alignment on PhxLevelPacingMeterManager_OnCheckpointReached");
static_assert(sizeof(PhxLevelPacingMeterManager_OnCheckpointReached) == 0x000008, "Wrong size on PhxLevelPacingMeterManager_OnCheckpointReached");
static_assert(offsetof(PhxLevelPacingMeterManager_OnCheckpointReached, Checkpoint) == 0x000000, "Member 'PhxLevelPacingMeterManager_OnCheckpointReached::Checkpoint' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.OnProgressBeginRestore
// 0x0008 (0x0008 - 0x0000)
struct PhxLevelPacingMeterManager_OnProgressBeginRestore final
{
public:
	class ACheckpoint*                            Checkpoint;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterManager_OnProgressBeginRestore) == 0x000008, "Wrong alignment on PhxLevelPacingMeterManager_OnProgressBeginRestore");
static_assert(sizeof(PhxLevelPacingMeterManager_OnProgressBeginRestore) == 0x000008, "Wrong size on PhxLevelPacingMeterManager_OnProgressBeginRestore");
static_assert(offsetof(PhxLevelPacingMeterManager_OnProgressBeginRestore, Checkpoint) == 0x000000, "Member 'PhxLevelPacingMeterManager_OnProgressBeginRestore::Checkpoint' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.OnProgressRestored
// 0x0008 (0x0008 - 0x0000)
struct PhxLevelPacingMeterManager_OnProgressRestored final
{
public:
	class ACheckpoint*                            Checkpoint;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterManager_OnProgressRestored) == 0x000008, "Wrong alignment on PhxLevelPacingMeterManager_OnProgressRestored");
static_assert(sizeof(PhxLevelPacingMeterManager_OnProgressRestored) == 0x000008, "Wrong size on PhxLevelPacingMeterManager_OnProgressRestored");
static_assert(offsetof(PhxLevelPacingMeterManager_OnProgressRestored, Checkpoint) == 0x000000, "Member 'PhxLevelPacingMeterManager_OnProgressRestored::Checkpoint' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.SetLevelSpaceActive
// 0x0030 (0x0030 - 0x0000)
struct PhxLevelPacingMeterManager_SetLevelSpaceActive final
{
public:
	TSoftObjectPtr<class APhxLevelPacingMeterSpace> SpacePtr;                                        // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsActive;                                         // 0x0028(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLevelPacingMeterManager_SetLevelSpaceActive) == 0x000008, "Wrong alignment on PhxLevelPacingMeterManager_SetLevelSpaceActive");
static_assert(sizeof(PhxLevelPacingMeterManager_SetLevelSpaceActive) == 0x000030, "Wrong size on PhxLevelPacingMeterManager_SetLevelSpaceActive");
static_assert(offsetof(PhxLevelPacingMeterManager_SetLevelSpaceActive, SpacePtr) == 0x000000, "Member 'PhxLevelPacingMeterManager_SetLevelSpaceActive::SpacePtr' has a wrong offset!");
static_assert(offsetof(PhxLevelPacingMeterManager_SetLevelSpaceActive, bIsActive) == 0x000028, "Member 'PhxLevelPacingMeterManager_SetLevelSpaceActive::bIsActive' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.SetLevelSpaceActiveByStaticIndex
// 0x0008 (0x0008 - 0x0000)
struct PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex final
{
public:
	int32                                         StaticArrayIndex;                                  // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsActive;                                          // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex) == 0x000004, "Wrong alignment on PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex");
static_assert(sizeof(PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex) == 0x000008, "Wrong size on PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex");
static_assert(offsetof(PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex, StaticArrayIndex) == 0x000000, "Member 'PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex::StaticArrayIndex' has a wrong offset!");
static_assert(offsetof(PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex, IsActive) == 0x000004, "Member 'PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex::IsActive' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.SetupLevelPacingMeter
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelPacingMeterManager_SetupLevelPacingMeter final
{
public:
	TArray<class APhxLevelPacingMeterSpace*>      NewLevelPacingSpaces;                              // 0x0000(0x0010)(Parm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterManager_SetupLevelPacingMeter) == 0x000008, "Wrong alignment on PhxLevelPacingMeterManager_SetupLevelPacingMeter");
static_assert(sizeof(PhxLevelPacingMeterManager_SetupLevelPacingMeter) == 0x000010, "Wrong size on PhxLevelPacingMeterManager_SetupLevelPacingMeter");
static_assert(offsetof(PhxLevelPacingMeterManager_SetupLevelPacingMeter, NewLevelPacingSpaces) == 0x000000, "Member 'PhxLevelPacingMeterManager_SetupLevelPacingMeter::NewLevelPacingSpaces' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.GetCurrentSpace
// 0x0008 (0x0008 - 0x0000)
struct PhxLevelPacingMeterManager_GetCurrentSpace final
{
public:
	class APhxLevelPacingMeterSpace*              ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterManager_GetCurrentSpace) == 0x000008, "Wrong alignment on PhxLevelPacingMeterManager_GetCurrentSpace");
static_assert(sizeof(PhxLevelPacingMeterManager_GetCurrentSpace) == 0x000008, "Wrong size on PhxLevelPacingMeterManager_GetCurrentSpace");
static_assert(offsetof(PhxLevelPacingMeterManager_GetCurrentSpace, ReturnValue) == 0x000000, "Member 'PhxLevelPacingMeterManager_GetCurrentSpace::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.GetDynamicSpaces
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelPacingMeterManager_GetDynamicSpaces final
{
public:
	TArray<class APhxLevelPacingMeterSpace*>      ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterManager_GetDynamicSpaces) == 0x000008, "Wrong alignment on PhxLevelPacingMeterManager_GetDynamicSpaces");
static_assert(sizeof(PhxLevelPacingMeterManager_GetDynamicSpaces) == 0x000010, "Wrong size on PhxLevelPacingMeterManager_GetDynamicSpaces");
static_assert(offsetof(PhxLevelPacingMeterManager_GetDynamicSpaces, ReturnValue) == 0x000000, "Member 'PhxLevelPacingMeterManager_GetDynamicSpaces::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.GetNonLevelSpaceTime
// 0x0004 (0x0004 - 0x0000)
struct PhxLevelPacingMeterManager_GetNonLevelSpaceTime final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterManager_GetNonLevelSpaceTime) == 0x000004, "Wrong alignment on PhxLevelPacingMeterManager_GetNonLevelSpaceTime");
static_assert(sizeof(PhxLevelPacingMeterManager_GetNonLevelSpaceTime) == 0x000004, "Wrong size on PhxLevelPacingMeterManager_GetNonLevelSpaceTime");
static_assert(offsetof(PhxLevelPacingMeterManager_GetNonLevelSpaceTime, ReturnValue) == 0x000000, "Member 'PhxLevelPacingMeterManager_GetNonLevelSpaceTime::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelPacingMeterManager.GetTotalTime
// 0x0004 (0x0004 - 0x0000)
struct PhxLevelPacingMeterManager_GetTotalTime final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelPacingMeterManager_GetTotalTime) == 0x000004, "Wrong alignment on PhxLevelPacingMeterManager_GetTotalTime");
static_assert(sizeof(PhxLevelPacingMeterManager_GetTotalTime) == 0x000004, "Wrong size on PhxLevelPacingMeterManager_GetTotalTime");
static_assert(offsetof(PhxLevelPacingMeterManager_GetTotalTime, ReturnValue) == 0x000000, "Member 'PhxLevelPacingMeterManager_GetTotalTime::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingManager.IsLevelTranstionDataLoaded
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelStreamingManager_IsLevelTranstionDataLoaded final
{
public:
	const class ULevelTransitionDataAsset*        LevelTransitionData;                               // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLevelStreamingManager_IsLevelTranstionDataLoaded) == 0x000008, "Wrong alignment on PhxLevelStreamingManager_IsLevelTranstionDataLoaded");
static_assert(sizeof(PhxLevelStreamingManager_IsLevelTranstionDataLoaded) == 0x000010, "Wrong size on PhxLevelStreamingManager_IsLevelTranstionDataLoaded");
static_assert(offsetof(PhxLevelStreamingManager_IsLevelTranstionDataLoaded, LevelTransitionData) == 0x000000, "Member 'PhxLevelStreamingManager_IsLevelTranstionDataLoaded::LevelTransitionData' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingManager_IsLevelTranstionDataLoaded, ReturnValue) == 0x000008, "Member 'PhxLevelStreamingManager_IsLevelTranstionDataLoaded::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingManager.IsPreloadLevelsLoaded
// 0x0010 (0x0010 - 0x0000)
struct PhxLevelStreamingManager_IsPreloadLevelsLoaded final
{
public:
	const class UPreloadLevelsDataAsset*          PreloadLevelsData;                                 // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLevelStreamingManager_IsPreloadLevelsLoaded) == 0x000008, "Wrong alignment on PhxLevelStreamingManager_IsPreloadLevelsLoaded");
static_assert(sizeof(PhxLevelStreamingManager_IsPreloadLevelsLoaded) == 0x000010, "Wrong size on PhxLevelStreamingManager_IsPreloadLevelsLoaded");
static_assert(offsetof(PhxLevelStreamingManager_IsPreloadLevelsLoaded, PreloadLevelsData) == 0x000000, "Member 'PhxLevelStreamingManager_IsPreloadLevelsLoaded::PreloadLevelsData' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingManager_IsPreloadLevelsLoaded, ReturnValue) == 0x000008, "Member 'PhxLevelStreamingManager_IsPreloadLevelsLoaded::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingManager.OpenLevelFromMenu
// 0x0008 (0x0008 - 0x0000)
struct PhxLevelStreamingManager_OpenLevelFromMenu final
{
public:
	const class ULevelTransitionDataAsset*        LevelTransitionData;                               // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelStreamingManager_OpenLevelFromMenu) == 0x000008, "Wrong alignment on PhxLevelStreamingManager_OpenLevelFromMenu");
static_assert(sizeof(PhxLevelStreamingManager_OpenLevelFromMenu) == 0x000008, "Wrong size on PhxLevelStreamingManager_OpenLevelFromMenu");
static_assert(offsetof(PhxLevelStreamingManager_OpenLevelFromMenu, LevelTransitionData) == 0x000000, "Member 'PhxLevelStreamingManager_OpenLevelFromMenu::LevelTransitionData' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingManager.PreloadLevels
// 0x0008 (0x0008 - 0x0000)
struct PhxLevelStreamingManager_PreloadLevels final
{
public:
	const class UPreloadLevelsDataAsset*          PreloadLevelsData;                                 // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelStreamingManager_PreloadLevels) == 0x000008, "Wrong alignment on PhxLevelStreamingManager_PreloadLevels");
static_assert(sizeof(PhxLevelStreamingManager_PreloadLevels) == 0x000008, "Wrong size on PhxLevelStreamingManager_PreloadLevels");
static_assert(offsetof(PhxLevelStreamingManager_PreloadLevels, PreloadLevelsData) == 0x000000, "Member 'PhxLevelStreamingManager_PreloadLevels::PreloadLevelsData' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingManager.TransitionToLevel
// 0x0020 (0x0020 - 0x0000)
struct PhxLevelStreamingManager_TransitionToLevel final
{
public:
	class FString                                 LevelName;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   TransitionEvent;                                   // 0x0010(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          WaitForTransitionCompleted;                        // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLevelStreamingManager_TransitionToLevel) == 0x000008, "Wrong alignment on PhxLevelStreamingManager_TransitionToLevel");
static_assert(sizeof(PhxLevelStreamingManager_TransitionToLevel) == 0x000020, "Wrong size on PhxLevelStreamingManager_TransitionToLevel");
static_assert(offsetof(PhxLevelStreamingManager_TransitionToLevel, LevelName) == 0x000000, "Member 'PhxLevelStreamingManager_TransitionToLevel::LevelName' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingManager_TransitionToLevel, TransitionEvent) == 0x000010, "Member 'PhxLevelStreamingManager_TransitionToLevel::TransitionEvent' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingManager_TransitionToLevel, WaitForTransitionCompleted) == 0x000018, "Member 'PhxLevelStreamingManager_TransitionToLevel::WaitForTransitionCompleted' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingManager.TransitionToLevelWithAsset
// 0x0020 (0x0020 - 0x0000)
struct PhxLevelStreamingManager_TransitionToLevelWithAsset final
{
public:
	const class ULevelTransitionDataAsset*        LevelTransitionData;                               // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class AActor*>                         ActorsToPreserveForTransition;                     // 0x0008(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          bSkipPlayerCheck;                                  // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLevelStreamingManager_TransitionToLevelWithAsset) == 0x000008, "Wrong alignment on PhxLevelStreamingManager_TransitionToLevelWithAsset");
static_assert(sizeof(PhxLevelStreamingManager_TransitionToLevelWithAsset) == 0x000020, "Wrong size on PhxLevelStreamingManager_TransitionToLevelWithAsset");
static_assert(offsetof(PhxLevelStreamingManager_TransitionToLevelWithAsset, LevelTransitionData) == 0x000000, "Member 'PhxLevelStreamingManager_TransitionToLevelWithAsset::LevelTransitionData' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingManager_TransitionToLevelWithAsset, ActorsToPreserveForTransition) == 0x000008, "Member 'PhxLevelStreamingManager_TransitionToLevelWithAsset::ActorsToPreserveForTransition' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingManager_TransitionToLevelWithAsset, bSkipPlayerCheck) == 0x000018, "Member 'PhxLevelStreamingManager_TransitionToLevelWithAsset::bSkipPlayerCheck' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingManager.IsInStreamingTransition
// 0x0001 (0x0001 - 0x0000)
struct PhxLevelStreamingManager_IsInStreamingTransition final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelStreamingManager_IsInStreamingTransition) == 0x000001, "Wrong alignment on PhxLevelStreamingManager_IsInStreamingTransition");
static_assert(sizeof(PhxLevelStreamingManager_IsInStreamingTransition) == 0x000001, "Wrong size on PhxLevelStreamingManager_IsInStreamingTransition");
static_assert(offsetof(PhxLevelStreamingManager_IsInStreamingTransition, ReturnValue) == 0x000000, "Member 'PhxLevelStreamingManager_IsInStreamingTransition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLevelStreamingBlueprintLibrary.GetStreamingVolumesNearActor
// 0x0020 (0x0020 - 0x0000)
struct PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor final
{
public:
	class AActor*                                 Actor;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIncludeTransitionVolumes;                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           ReturnValue;                                       // 0x0010(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor) == 0x000008, "Wrong alignment on PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor");
static_assert(sizeof(PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor) == 0x000020, "Wrong size on PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor");
static_assert(offsetof(PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor, Actor) == 0x000000, "Member 'PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor::Actor' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor, bIncludeTransitionVolumes) == 0x000008, "Member 'PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor::bIncludeTransitionVolumes' has a wrong offset!");
static_assert(offsetof(PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor, ReturnValue) == 0x000010, "Member 'PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxLightBlueprintLibrary.SetAffectsWorld
// 0x0010 (0x0010 - 0x0000)
struct PhxLightBlueprintLibrary_SetAffectsWorld final
{
public:
	class ULightComponentBase*                    LightComponentBase;                                // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAffectsWorld;                                     // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLightBlueprintLibrary_SetAffectsWorld) == 0x000008, "Wrong alignment on PhxLightBlueprintLibrary_SetAffectsWorld");
static_assert(sizeof(PhxLightBlueprintLibrary_SetAffectsWorld) == 0x000010, "Wrong size on PhxLightBlueprintLibrary_SetAffectsWorld");
static_assert(offsetof(PhxLightBlueprintLibrary_SetAffectsWorld, LightComponentBase) == 0x000000, "Member 'PhxLightBlueprintLibrary_SetAffectsWorld::LightComponentBase' has a wrong offset!");
static_assert(offsetof(PhxLightBlueprintLibrary_SetAffectsWorld, bAffectsWorld) == 0x000008, "Member 'PhxLightBlueprintLibrary_SetAffectsWorld::bAffectsWorld' has a wrong offset!");

// Function Phoenix.PhxLightFlickerController.InitializeFlickerController
// 0x0030 (0x0030 - 0x0000)
struct PhxLightFlickerController_InitializeFlickerController final
{
public:
	class UCurveFloat*                            InFlickerCurve;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class ULightComponent*>                InLightComponents;                                 // 0x0008(0x0010)(Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TArray<float>                                 InLightIntensities;                                // 0x0018(0x0010)(Parm, ZeroConstructor, NativeAccessSpecifierPublic)
	class UTimelineComponent*                     InTimelineComp;                                    // 0x0028(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLightFlickerController_InitializeFlickerController) == 0x000008, "Wrong alignment on PhxLightFlickerController_InitializeFlickerController");
static_assert(sizeof(PhxLightFlickerController_InitializeFlickerController) == 0x000030, "Wrong size on PhxLightFlickerController_InitializeFlickerController");
static_assert(offsetof(PhxLightFlickerController_InitializeFlickerController, InFlickerCurve) == 0x000000, "Member 'PhxLightFlickerController_InitializeFlickerController::InFlickerCurve' has a wrong offset!");
static_assert(offsetof(PhxLightFlickerController_InitializeFlickerController, InLightComponents) == 0x000008, "Member 'PhxLightFlickerController_InitializeFlickerController::InLightComponents' has a wrong offset!");
static_assert(offsetof(PhxLightFlickerController_InitializeFlickerController, InLightIntensities) == 0x000018, "Member 'PhxLightFlickerController_InitializeFlickerController::InLightIntensities' has a wrong offset!");
static_assert(offsetof(PhxLightFlickerController_InitializeFlickerController, InTimelineComp) == 0x000028, "Member 'PhxLightFlickerController_InitializeFlickerController::InTimelineComp' has a wrong offset!");

// Function Phoenix.PhxLightFlickerController.UpdateTimeFunc
// 0x0004 (0x0004 - 0x0000)
struct PhxLightFlickerController_UpdateTimeFunc final
{
public:
	float                                         Output;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLightFlickerController_UpdateTimeFunc) == 0x000004, "Wrong alignment on PhxLightFlickerController_UpdateTimeFunc");
static_assert(sizeof(PhxLightFlickerController_UpdateTimeFunc) == 0x000004, "Wrong size on PhxLightFlickerController_UpdateTimeFunc");
static_assert(offsetof(PhxLightFlickerController_UpdateTimeFunc, Output) == 0x000000, "Member 'PhxLightFlickerController_UpdateTimeFunc::Output' has a wrong offset!");

// Function Phoenix.PhxLimbActor.OnHit
// 0x00B0 (0x00B0 - 0x0000)
struct PhxLimbActor_OnHit final
{
public:
	class UPrimitiveComponent*                    HitComp;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalImpulse;                                     // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x0024(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLimbActor_OnHit) == 0x000008, "Wrong alignment on PhxLimbActor_OnHit");
static_assert(sizeof(PhxLimbActor_OnHit) == 0x0000B0, "Wrong size on PhxLimbActor_OnHit");
static_assert(offsetof(PhxLimbActor_OnHit, HitComp) == 0x000000, "Member 'PhxLimbActor_OnHit::HitComp' has a wrong offset!");
static_assert(offsetof(PhxLimbActor_OnHit, OtherActor) == 0x000008, "Member 'PhxLimbActor_OnHit::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxLimbActor_OnHit, OtherComp) == 0x000010, "Member 'PhxLimbActor_OnHit::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxLimbActor_OnHit, NormalImpulse) == 0x000018, "Member 'PhxLimbActor_OnHit::NormalImpulse' has a wrong offset!");
static_assert(offsetof(PhxLimbActor_OnHit, Hit) == 0x000024, "Member 'PhxLimbActor_OnHit::Hit' has a wrong offset!");

// Function Phoenix.PhxLimbActor.OnLimbReplicaFinished
// 0x0008 (0x0008 - 0x0000)
struct PhxLimbActor_OnLimbReplicaFinished final
{
public:
	const class USkeletalMeshComponent*           MainCopiedPart;                                    // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLimbActor_OnLimbReplicaFinished) == 0x000008, "Wrong alignment on PhxLimbActor_OnLimbReplicaFinished");
static_assert(sizeof(PhxLimbActor_OnLimbReplicaFinished) == 0x000008, "Wrong size on PhxLimbActor_OnLimbReplicaFinished");
static_assert(offsetof(PhxLimbActor_OnLimbReplicaFinished, MainCopiedPart) == 0x000000, "Member 'PhxLimbActor_OnLimbReplicaFinished::MainCopiedPart' has a wrong offset!");

// Function Phoenix.PhxLootDropFilter.PrepareForFiltering
// 0x0008 (0x0008 - 0x0000)
struct PhxLootDropFilter_PrepareForFiltering final
{
public:
	const class APhxCharacter*                    Character;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxLootDropFilter_PrepareForFiltering) == 0x000008, "Wrong alignment on PhxLootDropFilter_PrepareForFiltering");
static_assert(sizeof(PhxLootDropFilter_PrepareForFiltering) == 0x000008, "Wrong size on PhxLootDropFilter_PrepareForFiltering");
static_assert(offsetof(PhxLootDropFilter_PrepareForFiltering, Character) == 0x000000, "Member 'PhxLootDropFilter_PrepareForFiltering::Character' has a wrong offset!");

// Function Phoenix.PhxLootDropFilter.IsTableEntryValid
// 0x0050 (0x0050 - 0x0000)
struct PhxLootDropFilter_IsTableEntryValid final
{
public:
	const class APhxCharacter*                    Character;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FPhxLootDropData                       LootDropEntry;                                     // 0x0008(0x0040)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0048(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxLootDropFilter_IsTableEntryValid) == 0x000008, "Wrong alignment on PhxLootDropFilter_IsTableEntryValid");
static_assert(sizeof(PhxLootDropFilter_IsTableEntryValid) == 0x000050, "Wrong size on PhxLootDropFilter_IsTableEntryValid");
static_assert(offsetof(PhxLootDropFilter_IsTableEntryValid, Character) == 0x000000, "Member 'PhxLootDropFilter_IsTableEntryValid::Character' has a wrong offset!");
static_assert(offsetof(PhxLootDropFilter_IsTableEntryValid, LootDropEntry) == 0x000008, "Member 'PhxLootDropFilter_IsTableEntryValid::LootDropEntry' has a wrong offset!");
static_assert(offsetof(PhxLootDropFilter_IsTableEntryValid, ReturnValue) == 0x000048, "Member 'PhxLootDropFilter_IsTableEntryValid::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMarketingCameraHud.OnLeftStickAxisHorizontal
// 0x0004 (0x0004 - 0x0000)
struct PhxMarketingCameraHud_OnLeftStickAxisHorizontal final
{
public:
	float                                         StickVal;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMarketingCameraHud_OnLeftStickAxisHorizontal) == 0x000004, "Wrong alignment on PhxMarketingCameraHud_OnLeftStickAxisHorizontal");
static_assert(sizeof(PhxMarketingCameraHud_OnLeftStickAxisHorizontal) == 0x000004, "Wrong size on PhxMarketingCameraHud_OnLeftStickAxisHorizontal");
static_assert(offsetof(PhxMarketingCameraHud_OnLeftStickAxisHorizontal, StickVal) == 0x000000, "Member 'PhxMarketingCameraHud_OnLeftStickAxisHorizontal::StickVal' has a wrong offset!");

// Function Phoenix.PhxMarketingCameraHud.OnLeftStickAxisVertical
// 0x0004 (0x0004 - 0x0000)
struct PhxMarketingCameraHud_OnLeftStickAxisVertical final
{
public:
	float                                         StickVal;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMarketingCameraHud_OnLeftStickAxisVertical) == 0x000004, "Wrong alignment on PhxMarketingCameraHud_OnLeftStickAxisVertical");
static_assert(sizeof(PhxMarketingCameraHud_OnLeftStickAxisVertical) == 0x000004, "Wrong size on PhxMarketingCameraHud_OnLeftStickAxisVertical");
static_assert(offsetof(PhxMarketingCameraHud_OnLeftStickAxisVertical, StickVal) == 0x000000, "Member 'PhxMarketingCameraHud_OnLeftStickAxisVertical::StickVal' has a wrong offset!");

// Function Phoenix.PhxMeleeAttackDefinition.HasCondition
// 0x0002 (0x0002 - 0x0000)
struct PhxMeleeAttackDefinition_HasCondition final
{
public:
	EContextualAttackConditions                   Condition;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0001(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMeleeAttackDefinition_HasCondition) == 0x000001, "Wrong alignment on PhxMeleeAttackDefinition_HasCondition");
static_assert(sizeof(PhxMeleeAttackDefinition_HasCondition) == 0x000002, "Wrong size on PhxMeleeAttackDefinition_HasCondition");
static_assert(offsetof(PhxMeleeAttackDefinition_HasCondition, Condition) == 0x000000, "Member 'PhxMeleeAttackDefinition_HasCondition::Condition' has a wrong offset!");
static_assert(offsetof(PhxMeleeAttackDefinition_HasCondition, ReturnValue) == 0x000001, "Member 'PhxMeleeAttackDefinition_HasCondition::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMenuReaderComponent.AsyncLoadAudio
// 0x0010 (0x0010 - 0x0000)
struct PhxMenuReaderComponent_AsyncLoadAudio final
{
public:
	TArray<class FName>                           InTags;                                            // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMenuReaderComponent_AsyncLoadAudio) == 0x000008, "Wrong alignment on PhxMenuReaderComponent_AsyncLoadAudio");
static_assert(sizeof(PhxMenuReaderComponent_AsyncLoadAudio) == 0x000010, "Wrong size on PhxMenuReaderComponent_AsyncLoadAudio");
static_assert(offsetof(PhxMenuReaderComponent_AsyncLoadAudio, InTags) == 0x000000, "Member 'PhxMenuReaderComponent_AsyncLoadAudio::InTags' has a wrong offset!");

// Function Phoenix.PhxMenuReaderComponent.PlayMappedSound
// 0x0008 (0x0008 - 0x0000)
struct PhxMenuReaderComponent_PlayMappedSound final
{
public:
	class FName                                   InTag;                                             // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMenuReaderComponent_PlayMappedSound) == 0x000004, "Wrong alignment on PhxMenuReaderComponent_PlayMappedSound");
static_assert(sizeof(PhxMenuReaderComponent_PlayMappedSound) == 0x000008, "Wrong size on PhxMenuReaderComponent_PlayMappedSound");
static_assert(offsetof(PhxMenuReaderComponent_PlayMappedSound, InTag) == 0x000000, "Member 'PhxMenuReaderComponent_PlayMappedSound::InTag' has a wrong offset!");

// Function Phoenix.PhxMeshMergeFunctionLibrary.MergeMeshes
// 0x0048 (0x0048 - 0x0000)
struct PhxMeshMergeFunctionLibrary_MergeMeshes final
{
public:
	struct FPhxSkeletalMeshMergeParams            Params_0;                                          // 0x0000(0x0040)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class USkeletalMesh*                          ReturnValue;                                       // 0x0040(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMeshMergeFunctionLibrary_MergeMeshes) == 0x000008, "Wrong alignment on PhxMeshMergeFunctionLibrary_MergeMeshes");
static_assert(sizeof(PhxMeshMergeFunctionLibrary_MergeMeshes) == 0x000048, "Wrong size on PhxMeshMergeFunctionLibrary_MergeMeshes");
static_assert(offsetof(PhxMeshMergeFunctionLibrary_MergeMeshes, Params_0) == 0x000000, "Member 'PhxMeshMergeFunctionLibrary_MergeMeshes::Params_0' has a wrong offset!");
static_assert(offsetof(PhxMeshMergeFunctionLibrary_MergeMeshes, ReturnValue) == 0x000040, "Member 'PhxMeshMergeFunctionLibrary_MergeMeshes::ReturnValue' has a wrong offset!");

// Function Phoenix.SecureSafe.InteractExecuted
// 0x0008 (0x0008 - 0x0000)
struct SecureSafe_InteractExecuted final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SecureSafe_InteractExecuted) == 0x000008, "Wrong alignment on SecureSafe_InteractExecuted");
static_assert(sizeof(SecureSafe_InteractExecuted) == 0x000008, "Wrong size on SecureSafe_InteractExecuted");
static_assert(offsetof(SecureSafe_InteractExecuted, InteractedBy) == 0x000000, "Member 'SecureSafe_InteractExecuted::InteractedBy' has a wrong offset!");

// Function Phoenix.SecureSafe.OnKeypadCodeConfirmed
// 0x0001 (0x0001 - 0x0000)
struct SecureSafe_OnKeypadCodeConfirmed final
{
public:
	bool                                          bUnlocked;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SecureSafe_OnKeypadCodeConfirmed) == 0x000001, "Wrong alignment on SecureSafe_OnKeypadCodeConfirmed");
static_assert(sizeof(SecureSafe_OnKeypadCodeConfirmed) == 0x000001, "Wrong size on SecureSafe_OnKeypadCodeConfirmed");
static_assert(offsetof(SecureSafe_OnKeypadCodeConfirmed, bUnlocked) == 0x000000, "Member 'SecureSafe_OnKeypadCodeConfirmed::bUnlocked' has a wrong offset!");

// Function Phoenix.SecureSafe.ReceiveKeypadCodeConfirmed
// 0x0001 (0x0001 - 0x0000)
struct SecureSafe_ReceiveKeypadCodeConfirmed final
{
public:
	bool                                          bUnlocked;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SecureSafe_ReceiveKeypadCodeConfirmed) == 0x000001, "Wrong alignment on SecureSafe_ReceiveKeypadCodeConfirmed");
static_assert(sizeof(SecureSafe_ReceiveKeypadCodeConfirmed) == 0x000001, "Wrong size on SecureSafe_ReceiveKeypadCodeConfirmed");
static_assert(offsetof(SecureSafe_ReceiveKeypadCodeConfirmed, bUnlocked) == 0x000000, "Member 'SecureSafe_ReceiveKeypadCodeConfirmed::bUnlocked' has a wrong offset!");

// Function Phoenix.SecureSafe.GetKeypadUI
// 0x0008 (0x0008 - 0x0000)
struct SecureSafe_GetKeypadUI final
{
public:
	class AWSSafeKeypadUI*                        ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SecureSafe_GetKeypadUI) == 0x000008, "Wrong alignment on SecureSafe_GetKeypadUI");
static_assert(sizeof(SecureSafe_GetKeypadUI) == 0x000008, "Wrong size on SecureSafe_GetKeypadUI");
static_assert(offsetof(SecureSafe_GetKeypadUI, ReturnValue) == 0x000000, "Member 'SecureSafe_GetKeypadUI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMuckComponent.AddSimpleEffect
// 0x001C (0x001C - 0x0000)
struct PhxMuckComponent_AddSimpleEffect final
{
public:
	class FName                                   Name_0;                                            // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxMuckType                                  Type;                                              // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Intensity;                                         // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Level;                                             // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeInTime;                                        // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeOutTime;                                       // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMuckComponent_AddSimpleEffect) == 0x000004, "Wrong alignment on PhxMuckComponent_AddSimpleEffect");
static_assert(sizeof(PhxMuckComponent_AddSimpleEffect) == 0x00001C, "Wrong size on PhxMuckComponent_AddSimpleEffect");
static_assert(offsetof(PhxMuckComponent_AddSimpleEffect, Name_0) == 0x000000, "Member 'PhxMuckComponent_AddSimpleEffect::Name_0' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_AddSimpleEffect, Type) == 0x000008, "Member 'PhxMuckComponent_AddSimpleEffect::Type' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_AddSimpleEffect, Intensity) == 0x00000C, "Member 'PhxMuckComponent_AddSimpleEffect::Intensity' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_AddSimpleEffect, Level) == 0x000010, "Member 'PhxMuckComponent_AddSimpleEffect::Level' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_AddSimpleEffect, FadeInTime) == 0x000014, "Member 'PhxMuckComponent_AddSimpleEffect::FadeInTime' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_AddSimpleEffect, FadeOutTime) == 0x000018, "Member 'PhxMuckComponent_AddSimpleEffect::FadeOutTime' has a wrong offset!");

// Function Phoenix.PhxMuckComponent.IsInEffect
// 0x0020 (0x0020 - 0x0000)
struct PhxMuckComponent_IsInEffect final
{
public:
	EPhxMuckType                                  Type;                                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class AActor*                                 Owner;                                             // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Name_0;                                            // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TargetLevel;                                       // 0x0018(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsFadingOut;                                       // 0x001C(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x001D(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1E[0x2];                                       // 0x001E(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxMuckComponent_IsInEffect) == 0x000008, "Wrong alignment on PhxMuckComponent_IsInEffect");
static_assert(sizeof(PhxMuckComponent_IsInEffect) == 0x000020, "Wrong size on PhxMuckComponent_IsInEffect");
static_assert(offsetof(PhxMuckComponent_IsInEffect, Type) == 0x000000, "Member 'PhxMuckComponent_IsInEffect::Type' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_IsInEffect, Owner) == 0x000008, "Member 'PhxMuckComponent_IsInEffect::Owner' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_IsInEffect, Name_0) == 0x000010, "Member 'PhxMuckComponent_IsInEffect::Name_0' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_IsInEffect, TargetLevel) == 0x000018, "Member 'PhxMuckComponent_IsInEffect::TargetLevel' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_IsInEffect, IsFadingOut) == 0x00001C, "Member 'PhxMuckComponent_IsInEffect::IsFadingOut' has a wrong offset!");
static_assert(offsetof(PhxMuckComponent_IsInEffect, ReturnValue) == 0x00001D, "Member 'PhxMuckComponent_IsInEffect::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxMuckComponent.RemoveSimpleEffect
// 0x0008 (0x0008 - 0x0000)
struct PhxMuckComponent_RemoveSimpleEffect final
{
public:
	class FName                                   Name_0;                                            // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMuckComponent_RemoveSimpleEffect) == 0x000004, "Wrong alignment on PhxMuckComponent_RemoveSimpleEffect");
static_assert(sizeof(PhxMuckComponent_RemoveSimpleEffect) == 0x000008, "Wrong size on PhxMuckComponent_RemoveSimpleEffect");
static_assert(offsetof(PhxMuckComponent_RemoveSimpleEffect, Name_0) == 0x000000, "Member 'PhxMuckComponent_RemoveSimpleEffect::Name_0' has a wrong offset!");

// Function Phoenix.WSInventoryUI.GetInventoryWidget
// 0x0008 (0x0008 - 0x0000)
struct WSInventoryUI_GetInventoryWidget final
{
public:
	class UInventoryFrame*                        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInventoryUI_GetInventoryWidget) == 0x000008, "Wrong alignment on WSInventoryUI_GetInventoryWidget");
static_assert(sizeof(WSInventoryUI_GetInventoryWidget) == 0x000008, "Wrong size on WSInventoryUI_GetInventoryWidget");
static_assert(offsetof(WSInventoryUI_GetInventoryWidget, ReturnValue) == 0x000000, "Member 'WSInventoryUI_GetInventoryWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.WSInventoryUI.GetSelectables
// 0x0010 (0x0010 - 0x0000)
struct WSInventoryUI_GetSelectables final
{
public:
	TArray<class AWSSelectable*>                  ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInventoryUI_GetSelectables) == 0x000008, "Wrong alignment on WSInventoryUI_GetSelectables");
static_assert(sizeof(WSInventoryUI_GetSelectables) == 0x000010, "Wrong size on WSInventoryUI_GetSelectables");
static_assert(offsetof(WSInventoryUI_GetSelectables, ReturnValue) == 0x000000, "Member 'WSInventoryUI_GetSelectables::ReturnValue' has a wrong offset!");

// Function Phoenix.WSInventoryUI.GetWorldLocationOnCylinder
// 0x0020 (0x0020 - 0x0000)
struct WSInventoryUI_GetWorldLocationOnCylinder final
{
public:
	struct FVector2D                              ElementLocation;                                   // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                OutLocation;                                       // 0x0008(0x000C)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               OutRotator;                                        // 0x0014(0x000C)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInventoryUI_GetWorldLocationOnCylinder) == 0x000004, "Wrong alignment on WSInventoryUI_GetWorldLocationOnCylinder");
static_assert(sizeof(WSInventoryUI_GetWorldLocationOnCylinder) == 0x000020, "Wrong size on WSInventoryUI_GetWorldLocationOnCylinder");
static_assert(offsetof(WSInventoryUI_GetWorldLocationOnCylinder, ElementLocation) == 0x000000, "Member 'WSInventoryUI_GetWorldLocationOnCylinder::ElementLocation' has a wrong offset!");
static_assert(offsetof(WSInventoryUI_GetWorldLocationOnCylinder, OutLocation) == 0x000008, "Member 'WSInventoryUI_GetWorldLocationOnCylinder::OutLocation' has a wrong offset!");
static_assert(offsetof(WSInventoryUI_GetWorldLocationOnCylinder, OutRotator) == 0x000014, "Member 'WSInventoryUI_GetWorldLocationOnCylinder::OutRotator' has a wrong offset!");

// Function Phoenix.PhxMusicManager.EnableCombatMusic
// 0x0008 (0x0008 - 0x0000)
struct PhxMusicManager_EnableCombatMusic final
{
public:
	EPhxEncounterIntensity                        CombatIntensity;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          StartOnPreCombat;                                  // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          BypassKickoff;                                     // 0x0002(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IntensityCanDrop;                                  // 0x0003(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KickoffDelayInSeconds;                             // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_EnableCombatMusic) == 0x000004, "Wrong alignment on PhxMusicManager_EnableCombatMusic");
static_assert(sizeof(PhxMusicManager_EnableCombatMusic) == 0x000008, "Wrong size on PhxMusicManager_EnableCombatMusic");
static_assert(offsetof(PhxMusicManager_EnableCombatMusic, CombatIntensity) == 0x000000, "Member 'PhxMusicManager_EnableCombatMusic::CombatIntensity' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_EnableCombatMusic, StartOnPreCombat) == 0x000001, "Member 'PhxMusicManager_EnableCombatMusic::StartOnPreCombat' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_EnableCombatMusic, BypassKickoff) == 0x000002, "Member 'PhxMusicManager_EnableCombatMusic::BypassKickoff' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_EnableCombatMusic, IntensityCanDrop) == 0x000003, "Member 'PhxMusicManager_EnableCombatMusic::IntensityCanDrop' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_EnableCombatMusic, KickoffDelayInSeconds) == 0x000004, "Member 'PhxMusicManager_EnableCombatMusic::KickoffDelayInSeconds' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnAllEnemiesOfClassUnawareOfPlayer
// 0x0010 (0x0010 - 0x0000)
struct PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 LastEnemy;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer) == 0x000008, "Wrong alignment on PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer");
static_assert(sizeof(PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer) == 0x000010, "Wrong size on PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer");
static_assert(offsetof(PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer, GameStateManager) == 0x000000, "Member 'PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer, LastEnemy) == 0x000008, "Member 'PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer::LastEnemy' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnCombatStateChanged
// 0x0010 (0x0010 - 0x0000)
struct PhxMusicManager_OnCombatStateChanged final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               PreviousGameState;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               NewGameState;                                      // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxMusicManager_OnCombatStateChanged) == 0x000008, "Wrong alignment on PhxMusicManager_OnCombatStateChanged");
static_assert(sizeof(PhxMusicManager_OnCombatStateChanged) == 0x000010, "Wrong size on PhxMusicManager_OnCombatStateChanged");
static_assert(offsetof(PhxMusicManager_OnCombatStateChanged, GameStateManager) == 0x000000, "Member 'PhxMusicManager_OnCombatStateChanged::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnCombatStateChanged, PreviousGameState) == 0x000008, "Member 'PhxMusicManager_OnCombatStateChanged::PreviousGameState' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnCombatStateChanged, NewGameState) == 0x000009, "Member 'PhxMusicManager_OnCombatStateChanged::NewGameState' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnEnemyDamaged
// 0x0028 (0x0028 - 0x0000)
struct PhxMusicManager_OnEnemyDamaged final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0018(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxMusicManager_OnEnemyDamaged) == 0x000008, "Wrong alignment on PhxMusicManager_OnEnemyDamaged");
static_assert(sizeof(PhxMusicManager_OnEnemyDamaged) == 0x000028, "Wrong size on PhxMusicManager_OnEnemyDamaged");
static_assert(offsetof(PhxMusicManager_OnEnemyDamaged, GameStateManager) == 0x000000, "Member 'PhxMusicManager_OnEnemyDamaged::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnEnemyDamaged, Enemy) == 0x000008, "Member 'PhxMusicManager_OnEnemyDamaged::Enemy' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnEnemyDamaged, DamageCauser) == 0x000010, "Member 'PhxMusicManager_OnEnemyDamaged::DamageCauser' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnEnemyDamaged, DamageType) == 0x000018, "Member 'PhxMusicManager_OnEnemyDamaged::DamageType' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnEnemyDamaged, Damage) == 0x000020, "Member 'PhxMusicManager_OnEnemyDamaged::Damage' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnEnemyDied
// 0x0018 (0x0018 - 0x0000)
struct PhxMusicManager_OnEnemyDied final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_OnEnemyDied) == 0x000008, "Wrong alignment on PhxMusicManager_OnEnemyDied");
static_assert(sizeof(PhxMusicManager_OnEnemyDied) == 0x000018, "Wrong size on PhxMusicManager_OnEnemyDied");
static_assert(offsetof(PhxMusicManager_OnEnemyDied, GameStateManager) == 0x000000, "Member 'PhxMusicManager_OnEnemyDied::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnEnemyDied, Enemy) == 0x000008, "Member 'PhxMusicManager_OnEnemyDied::Enemy' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnEnemyDied, KillerController) == 0x000010, "Member 'PhxMusicManager_OnEnemyDied::KillerController' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnEnemySpawned
// 0x0010 (0x0010 - 0x0000)
struct PhxMusicManager_OnEnemySpawned final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_OnEnemySpawned) == 0x000008, "Wrong alignment on PhxMusicManager_OnEnemySpawned");
static_assert(sizeof(PhxMusicManager_OnEnemySpawned) == 0x000010, "Wrong size on PhxMusicManager_OnEnemySpawned");
static_assert(offsetof(PhxMusicManager_OnEnemySpawned, GameStateManager) == 0x000000, "Member 'PhxMusicManager_OnEnemySpawned::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnEnemySpawned, Enemy) == 0x000008, "Member 'PhxMusicManager_OnEnemySpawned::Enemy' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnFirstEnemyOfClassAwareOfPlayer
// 0x0010 (0x0010 - 0x0000)
struct PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 FirstEnemy;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer) == 0x000008, "Wrong alignment on PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer");
static_assert(sizeof(PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer) == 0x000010, "Wrong size on PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer");
static_assert(offsetof(PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer, GameStateManager) == 0x000000, "Member 'PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer, FirstEnemy) == 0x000008, "Member 'PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer::FirstEnemy' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnLastEnemyDied
// 0x0018 (0x0018 - 0x0000)
struct PhxMusicManager_OnLastEnemyDied final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_OnLastEnemyDied) == 0x000008, "Wrong alignment on PhxMusicManager_OnLastEnemyDied");
static_assert(sizeof(PhxMusicManager_OnLastEnemyDied) == 0x000018, "Wrong size on PhxMusicManager_OnLastEnemyDied");
static_assert(offsetof(PhxMusicManager_OnLastEnemyDied, GameStateManager) == 0x000000, "Member 'PhxMusicManager_OnLastEnemyDied::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnLastEnemyDied, Enemy) == 0x000008, "Member 'PhxMusicManager_OnLastEnemyDied::Enemy' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnLastEnemyDied, KillerController) == 0x000010, "Member 'PhxMusicManager_OnLastEnemyDied::KillerController' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnPlayerDamaged
// 0x0028 (0x0028 - 0x0000)
struct PhxMusicManager_OnPlayerDamaged final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_OnPlayerDamaged) == 0x000008, "Wrong alignment on PhxMusicManager_OnPlayerDamaged");
static_assert(sizeof(PhxMusicManager_OnPlayerDamaged) == 0x000028, "Wrong size on PhxMusicManager_OnPlayerDamaged");
static_assert(offsetof(PhxMusicManager_OnPlayerDamaged, DamagedActor) == 0x000000, "Member 'PhxMusicManager_OnPlayerDamaged::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnPlayerDamaged, Damage) == 0x000008, "Member 'PhxMusicManager_OnPlayerDamaged::Damage' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnPlayerDamaged, DamageType) == 0x000010, "Member 'PhxMusicManager_OnPlayerDamaged::DamageType' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnPlayerDamaged, InstigatedBy) == 0x000018, "Member 'PhxMusicManager_OnPlayerDamaged::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnPlayerDamaged, DamageCauser) == 0x000020, "Member 'PhxMusicManager_OnPlayerDamaged::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnPlayerDied
// 0x0020 (0x0020 - 0x0000)
struct PhxMusicManager_OnPlayerDied final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxMusicManager_OnPlayerDied) == 0x000008, "Wrong alignment on PhxMusicManager_OnPlayerDied");
static_assert(sizeof(PhxMusicManager_OnPlayerDied) == 0x000020, "Wrong size on PhxMusicManager_OnPlayerDied");
static_assert(offsetof(PhxMusicManager_OnPlayerDied, DeadCharacter) == 0x000000, "Member 'PhxMusicManager_OnPlayerDied::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnPlayerDied, KillerActor) == 0x000008, "Member 'PhxMusicManager_OnPlayerDied::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnPlayerDied, KillerController) == 0x000010, "Member 'PhxMusicManager_OnPlayerDied::KillerController' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnPlayerDied, KillingBlowHealthDelta) == 0x000018, "Member 'PhxMusicManager_OnPlayerDied::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnQteCanceled
// 0x0008 (0x0008 - 0x0000)
struct PhxMusicManager_OnQteCanceled final
{
public:
	class FName                                   QteId;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_OnQteCanceled) == 0x000004, "Wrong alignment on PhxMusicManager_OnQteCanceled");
static_assert(sizeof(PhxMusicManager_OnQteCanceled) == 0x000008, "Wrong size on PhxMusicManager_OnQteCanceled");
static_assert(offsetof(PhxMusicManager_OnQteCanceled, QteId) == 0x000000, "Member 'PhxMusicManager_OnQteCanceled::QteId' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnQteComplete
// 0x000C (0x000C - 0x0000)
struct PhxMusicManager_OnQteComplete final
{
public:
	class FName                                   QteId;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bResult;                                           // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxMusicManager_OnQteComplete) == 0x000004, "Wrong alignment on PhxMusicManager_OnQteComplete");
static_assert(sizeof(PhxMusicManager_OnQteComplete) == 0x00000C, "Wrong size on PhxMusicManager_OnQteComplete");
static_assert(offsetof(PhxMusicManager_OnQteComplete, QteId) == 0x000000, "Member 'PhxMusicManager_OnQteComplete::QteId' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnQteComplete, bResult) == 0x000008, "Member 'PhxMusicManager_OnQteComplete::bResult' has a wrong offset!");

// Function Phoenix.PhxMusicManager.OnSoundEventCallback
// 0x0010 (0x0010 - 0x0000)
struct PhxMusicManager_OnSoundEventCallback final
{
public:
	EAkCallbackType                               CallbackType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UAkCallbackInfo*                        CallbackInfo;                                      // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_OnSoundEventCallback) == 0x000008, "Wrong alignment on PhxMusicManager_OnSoundEventCallback");
static_assert(sizeof(PhxMusicManager_OnSoundEventCallback) == 0x000010, "Wrong size on PhxMusicManager_OnSoundEventCallback");
static_assert(offsetof(PhxMusicManager_OnSoundEventCallback, CallbackType) == 0x000000, "Member 'PhxMusicManager_OnSoundEventCallback::CallbackType' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_OnSoundEventCallback, CallbackInfo) == 0x000008, "Member 'PhxMusicManager_OnSoundEventCallback::CallbackInfo' has a wrong offset!");

// Function Phoenix.PhxMusicManager.PostMusicEvent
// 0x0008 (0x0008 - 0x0000)
struct PhxMusicManager_PostMusicEvent final
{
public:
	class UAkAudioEvent*                          musicEvent;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_PostMusicEvent) == 0x000008, "Wrong alignment on PhxMusicManager_PostMusicEvent");
static_assert(sizeof(PhxMusicManager_PostMusicEvent) == 0x000008, "Wrong size on PhxMusicManager_PostMusicEvent");
static_assert(offsetof(PhxMusicManager_PostMusicEvent, musicEvent) == 0x000000, "Member 'PhxMusicManager_PostMusicEvent::musicEvent' has a wrong offset!");

// Function Phoenix.PhxMusicManager.SetRTPC
// 0x0010 (0x0010 - 0x0000)
struct PhxMusicManager_SetRTPC final
{
public:
	class UAkRtpc*                                RtpcIn;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Value;                                             // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxMusicManager_SetRTPC) == 0x000008, "Wrong alignment on PhxMusicManager_SetRTPC");
static_assert(sizeof(PhxMusicManager_SetRTPC) == 0x000010, "Wrong size on PhxMusicManager_SetRTPC");
static_assert(offsetof(PhxMusicManager_SetRTPC, RtpcIn) == 0x000000, "Member 'PhxMusicManager_SetRTPC::RtpcIn' has a wrong offset!");
static_assert(offsetof(PhxMusicManager_SetRTPC, Value) == 0x000008, "Member 'PhxMusicManager_SetRTPC::Value' has a wrong offset!");

// Function Phoenix.PhxMusicManager.SetSwitch
// 0x0008 (0x0008 - 0x0000)
struct PhxMusicManager_SetSwitch final
{
public:
	class UAkSwitchValue*                         SwitchIn;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxMusicManager_SetSwitch) == 0x000008, "Wrong alignment on PhxMusicManager_SetSwitch");
static_assert(sizeof(PhxMusicManager_SetSwitch) == 0x000008, "Wrong size on PhxMusicManager_SetSwitch");
static_assert(offsetof(PhxMusicManager_SetSwitch, SwitchIn) == 0x000000, "Member 'PhxMusicManager_SetSwitch::SwitchIn' has a wrong offset!");

// Function Phoenix.PhxPigPlatform.OnPigSpeedUpdated
// 0x0004 (0x0004 - 0x0000)
struct PhxPigPlatform_OnPigSpeedUpdated final
{
public:
	float                                         NewSpeed;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPigPlatform_OnPigSpeedUpdated) == 0x000004, "Wrong alignment on PhxPigPlatform_OnPigSpeedUpdated");
static_assert(sizeof(PhxPigPlatform_OnPigSpeedUpdated) == 0x000004, "Wrong size on PhxPigPlatform_OnPigSpeedUpdated");
static_assert(offsetof(PhxPigPlatform_OnPigSpeedUpdated, NewSpeed) == 0x000000, "Member 'PhxPigPlatform_OnPigSpeedUpdated::NewSpeed' has a wrong offset!");

// Function Phoenix.PhxPigPlatform.SetShouldTiltPlatform
// 0x0002 (0x0002 - 0x0000)
struct PhxPigPlatform_SetShouldTiltPlatform final
{
public:
	bool                                          bShouldTilt;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bResetRoll;                                        // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPigPlatform_SetShouldTiltPlatform) == 0x000001, "Wrong alignment on PhxPigPlatform_SetShouldTiltPlatform");
static_assert(sizeof(PhxPigPlatform_SetShouldTiltPlatform) == 0x000002, "Wrong size on PhxPigPlatform_SetShouldTiltPlatform");
static_assert(offsetof(PhxPigPlatform_SetShouldTiltPlatform, bShouldTilt) == 0x000000, "Member 'PhxPigPlatform_SetShouldTiltPlatform::bShouldTilt' has a wrong offset!");
static_assert(offsetof(PhxPigPlatform_SetShouldTiltPlatform, bResetRoll) == 0x000001, "Member 'PhxPigPlatform_SetShouldTiltPlatform::bResetRoll' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.AddAmmoToInventory
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCharacter_AddAmmoToInventory final
{
public:
	int32                                         AmmoToAdd;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_AddAmmoToInventory) == 0x000004, "Wrong alignment on PhxPlayerCharacter_AddAmmoToInventory");
static_assert(sizeof(PhxPlayerCharacter_AddAmmoToInventory) == 0x000004, "Wrong size on PhxPlayerCharacter_AddAmmoToInventory");
static_assert(offsetof(PhxPlayerCharacter_AddAmmoToInventory, AmmoToAdd) == 0x000000, "Member 'PhxPlayerCharacter_AddAmmoToInventory::AmmoToAdd' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.DamagePlayer
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerCharacter_DamagePlayer final
{
public:
	float                                         DamageAmount;                                      // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsLethal;                                         // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerCharacter_DamagePlayer) == 0x000004, "Wrong alignment on PhxPlayerCharacter_DamagePlayer");
static_assert(sizeof(PhxPlayerCharacter_DamagePlayer) == 0x000008, "Wrong size on PhxPlayerCharacter_DamagePlayer");
static_assert(offsetof(PhxPlayerCharacter_DamagePlayer, DamageAmount) == 0x000000, "Member 'PhxPlayerCharacter_DamagePlayer::DamageAmount' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_DamagePlayer, bIsLethal) == 0x000004, "Member 'PhxPlayerCharacter_DamagePlayer::bIsLethal' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.GetItemDropsHistory
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerCharacter_GetItemDropsHistory final
{
public:
	TArray<TSoftClassPtr<class UClass>>           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_GetItemDropsHistory) == 0x000008, "Wrong alignment on PhxPlayerCharacter_GetItemDropsHistory");
static_assert(sizeof(PhxPlayerCharacter_GetItemDropsHistory) == 0x000010, "Wrong size on PhxPlayerCharacter_GetItemDropsHistory");
static_assert(offsetof(PhxPlayerCharacter_GetItemDropsHistory, ReturnValue) == 0x000000, "Member 'PhxPlayerCharacter_GetItemDropsHistory::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.HandleAIGameStateChanged
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerCharacter_HandleAIGameStateChanged final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               PreviousGameState;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxAIGameState                               NewGameState;                                      // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerCharacter_HandleAIGameStateChanged) == 0x000008, "Wrong alignment on PhxPlayerCharacter_HandleAIGameStateChanged");
static_assert(sizeof(PhxPlayerCharacter_HandleAIGameStateChanged) == 0x000010, "Wrong size on PhxPlayerCharacter_HandleAIGameStateChanged");
static_assert(offsetof(PhxPlayerCharacter_HandleAIGameStateChanged, GameStateManager) == 0x000000, "Member 'PhxPlayerCharacter_HandleAIGameStateChanged::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_HandleAIGameStateChanged, PreviousGameState) == 0x000008, "Member 'PhxPlayerCharacter_HandleAIGameStateChanged::PreviousGameState' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_HandleAIGameStateChanged, NewGameState) == 0x000009, "Member 'PhxPlayerCharacter_HandleAIGameStateChanged::NewGameState' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.HasDLCEntitlement
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerCharacter_HasDLCEntitlement final
{
public:
	TArray<bool>                                  EntitlementResults;                                // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_HasDLCEntitlement) == 0x000008, "Wrong alignment on PhxPlayerCharacter_HasDLCEntitlement");
static_assert(sizeof(PhxPlayerCharacter_HasDLCEntitlement) == 0x000010, "Wrong size on PhxPlayerCharacter_HasDLCEntitlement");
static_assert(offsetof(PhxPlayerCharacter_HasDLCEntitlement, EntitlementResults) == 0x000000, "Member 'PhxPlayerCharacter_HasDLCEntitlement::EntitlementResults' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.HealPlayer
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCharacter_HealPlayer final
{
public:
	float                                         HealAmount;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_HealPlayer) == 0x000004, "Wrong alignment on PhxPlayerCharacter_HealPlayer");
static_assert(sizeof(PhxPlayerCharacter_HealPlayer) == 0x000004, "Wrong size on PhxPlayerCharacter_HealPlayer");
static_assert(offsetof(PhxPlayerCharacter_HealPlayer, HealAmount) == 0x000000, "Member 'PhxPlayerCharacter_HealPlayer::HealAmount' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.OnDefensiveActionEnded
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerCharacter_OnDefensiveActionEnded final
{
public:
	EReactionType                                 ReactionType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_OnDefensiveActionEnded) == 0x000001, "Wrong alignment on PhxPlayerCharacter_OnDefensiveActionEnded");
static_assert(sizeof(PhxPlayerCharacter_OnDefensiveActionEnded) == 0x000001, "Wrong size on PhxPlayerCharacter_OnDefensiveActionEnded");
static_assert(offsetof(PhxPlayerCharacter_OnDefensiveActionEnded, ReactionType) == 0x000000, "Member 'PhxPlayerCharacter_OnDefensiveActionEnded::ReactionType' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.OnDefensiveActionStarted
// 0x0100 (0x0100 - 0x0000)
struct PhxPlayerCharacter_OnDefensiveActionStarted final
{
public:
	EReactionType                                 ReactionType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefensiveReactDirection                      ReactionDir;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2[0x6];                                        // 0x0002(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitRecord                             HitRecord;                                         // 0x0008(0x00F8)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_OnDefensiveActionStarted) == 0x000008, "Wrong alignment on PhxPlayerCharacter_OnDefensiveActionStarted");
static_assert(sizeof(PhxPlayerCharacter_OnDefensiveActionStarted) == 0x000100, "Wrong size on PhxPlayerCharacter_OnDefensiveActionStarted");
static_assert(offsetof(PhxPlayerCharacter_OnDefensiveActionStarted, ReactionType) == 0x000000, "Member 'PhxPlayerCharacter_OnDefensiveActionStarted::ReactionType' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnDefensiveActionStarted, ReactionDir) == 0x000001, "Member 'PhxPlayerCharacter_OnDefensiveActionStarted::ReactionDir' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnDefensiveActionStarted, HitRecord) == 0x000008, "Member 'PhxPlayerCharacter_OnDefensiveActionStarted::HitRecord' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.OnEquipmentModifiedUpdateBlackBox
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox final
{
public:
	class AEquippable*                            CurrentEquipped;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AEquippable*                            CurrentEquippedAux;                                // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox) == 0x000008, "Wrong alignment on PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox");
static_assert(sizeof(PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox) == 0x000010, "Wrong size on PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox");
static_assert(offsetof(PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox, CurrentEquipped) == 0x000000, "Member 'PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox::CurrentEquipped' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox, CurrentEquippedAux) == 0x000008, "Member 'PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox::CurrentEquippedAux' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.OnGrappled
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerCharacter_OnGrappled final
{
public:
	class APhxCharacter*                          PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UGrappledPuppetState*                   GrappledPuppetState;                               // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_OnGrappled) == 0x000008, "Wrong alignment on PhxPlayerCharacter_OnGrappled");
static_assert(sizeof(PhxPlayerCharacter_OnGrappled) == 0x000010, "Wrong size on PhxPlayerCharacter_OnGrappled");
static_assert(offsetof(PhxPlayerCharacter_OnGrappled, PlayerCharacter) == 0x000000, "Member 'PhxPlayerCharacter_OnGrappled::PlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnGrappled, GrappledPuppetState) == 0x000008, "Member 'PhxPlayerCharacter_OnGrappled::GrappledPuppetState' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.OnHealthModified
// 0x0028 (0x0028 - 0x0000)
struct PhxPlayerCharacter_OnHealthModified final
{
public:
	class UPhxHealthComponent*                    HealthComponent;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HealthDelta;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_OnHealthModified) == 0x000008, "Wrong alignment on PhxPlayerCharacter_OnHealthModified");
static_assert(sizeof(PhxPlayerCharacter_OnHealthModified) == 0x000028, "Wrong size on PhxPlayerCharacter_OnHealthModified");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModified, HealthComponent) == 0x000000, "Member 'PhxPlayerCharacter_OnHealthModified::HealthComponent' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModified, Health) == 0x000008, "Member 'PhxPlayerCharacter_OnHealthModified::Health' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModified, HealthDelta) == 0x00000C, "Member 'PhxPlayerCharacter_OnHealthModified::HealthDelta' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModified, DamageType) == 0x000010, "Member 'PhxPlayerCharacter_OnHealthModified::DamageType' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModified, InstigatedBy) == 0x000018, "Member 'PhxPlayerCharacter_OnHealthModified::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModified, DamageCauser) == 0x000020, "Member 'PhxPlayerCharacter_OnHealthModified::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.OnHealthModifiedUpdateBlackBox
// 0x0028 (0x0028 - 0x0000)
struct PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox final
{
public:
	class UPhxHealthComponent*                    HealthComponent;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HealthDelta;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox) == 0x000008, "Wrong alignment on PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox");
static_assert(sizeof(PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox) == 0x000028, "Wrong size on PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox, HealthComponent) == 0x000000, "Member 'PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox::HealthComponent' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox, Health) == 0x000008, "Member 'PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox::Health' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox, HealthDelta) == 0x00000C, "Member 'PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox::HealthDelta' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox, DamageType) == 0x000010, "Member 'PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox::DamageType' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox, InstigatedBy) == 0x000018, "Member 'PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox, DamageCauser) == 0x000020, "Member 'PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.OnItemCountModifiedUpdateBlackBox
// 0x000C (0x000C - 0x0000)
struct PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox final
{
public:
	class FName                                   ItemName;                                          // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Quantity;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox) == 0x000004, "Wrong alignment on PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox");
static_assert(sizeof(PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox) == 0x00000C, "Wrong size on PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox");
static_assert(offsetof(PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox, ItemName) == 0x000000, "Member 'PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox::ItemName' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox, Quantity) == 0x000008, "Member 'PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox::Quantity' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.OnWeaponSkinChanged
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerCharacter_OnWeaponSkinChanged final
{
public:
	struct FGameplayTag                           WeaponTag;                                         // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_OnWeaponSkinChanged) == 0x000004, "Wrong alignment on PhxPlayerCharacter_OnWeaponSkinChanged");
static_assert(sizeof(PhxPlayerCharacter_OnWeaponSkinChanged) == 0x000008, "Wrong size on PhxPlayerCharacter_OnWeaponSkinChanged");
static_assert(offsetof(PhxPlayerCharacter_OnWeaponSkinChanged, WeaponTag) == 0x000000, "Member 'PhxPlayerCharacter_OnWeaponSkinChanged::WeaponTag' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.PROTOTYPE_RequestEnterPipeSlide
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerCharacter_PROTOTYPE_RequestEnterPipeSlide final
{
public:
	class APipeSlideSpline*                       SplineActor;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_PROTOTYPE_RequestEnterPipeSlide) == 0x000008, "Wrong alignment on PhxPlayerCharacter_PROTOTYPE_RequestEnterPipeSlide");
static_assert(sizeof(PhxPlayerCharacter_PROTOTYPE_RequestEnterPipeSlide) == 0x000008, "Wrong size on PhxPlayerCharacter_PROTOTYPE_RequestEnterPipeSlide");
static_assert(offsetof(PhxPlayerCharacter_PROTOTYPE_RequestEnterPipeSlide, SplineActor) == 0x000000, "Member 'PhxPlayerCharacter_PROTOTYPE_RequestEnterPipeSlide::SplineActor' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.RemoveAmmoFromInventory
// 0x0004 (0x0004 - 0x0000)
struct PhxPlayerCharacter_RemoveAmmoFromInventory final
{
public:
	int32                                         AmmoToRemove;                                      // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_RemoveAmmoFromInventory) == 0x000004, "Wrong alignment on PhxPlayerCharacter_RemoveAmmoFromInventory");
static_assert(sizeof(PhxPlayerCharacter_RemoveAmmoFromInventory) == 0x000004, "Wrong size on PhxPlayerCharacter_RemoveAmmoFromInventory");
static_assert(offsetof(PhxPlayerCharacter_RemoveAmmoFromInventory, AmmoToRemove) == 0x000000, "Member 'PhxPlayerCharacter_RemoveAmmoFromInventory::AmmoToRemove' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.RequestEnterChainLadder
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerCharacter_RequestEnterChainLadder final
{
public:
	class AChainLadder*                           ChainLadder;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_RequestEnterChainLadder) == 0x000008, "Wrong alignment on PhxPlayerCharacter_RequestEnterChainLadder");
static_assert(sizeof(PhxPlayerCharacter_RequestEnterChainLadder) == 0x000008, "Wrong size on PhxPlayerCharacter_RequestEnterChainLadder");
static_assert(offsetof(PhxPlayerCharacter_RequestEnterChainLadder, ChainLadder) == 0x000000, "Member 'PhxPlayerCharacter_RequestEnterChainLadder::ChainLadder' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.RequestHardCameraLookAt
// 0x0020 (0x0020 - 0x0000)
struct PhxPlayerCharacter_RequestHardCameraLookAt final
{
public:
	class AActor*                                 TargetActor;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   TargetBone;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BlendInTime;                                       // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BlendOutTime;                                      // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Duration;                                          // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AbortDistance;                                     // 0x001C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_RequestHardCameraLookAt) == 0x000008, "Wrong alignment on PhxPlayerCharacter_RequestHardCameraLookAt");
static_assert(sizeof(PhxPlayerCharacter_RequestHardCameraLookAt) == 0x000020, "Wrong size on PhxPlayerCharacter_RequestHardCameraLookAt");
static_assert(offsetof(PhxPlayerCharacter_RequestHardCameraLookAt, TargetActor) == 0x000000, "Member 'PhxPlayerCharacter_RequestHardCameraLookAt::TargetActor' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestHardCameraLookAt, TargetBone) == 0x000008, "Member 'PhxPlayerCharacter_RequestHardCameraLookAt::TargetBone' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestHardCameraLookAt, BlendInTime) == 0x000010, "Member 'PhxPlayerCharacter_RequestHardCameraLookAt::BlendInTime' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestHardCameraLookAt, BlendOutTime) == 0x000014, "Member 'PhxPlayerCharacter_RequestHardCameraLookAt::BlendOutTime' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestHardCameraLookAt, Duration) == 0x000018, "Member 'PhxPlayerCharacter_RequestHardCameraLookAt::Duration' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestHardCameraLookAt, AbortDistance) == 0x00001C, "Member 'PhxPlayerCharacter_RequestHardCameraLookAt::AbortDistance' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.RequestLinkedNodeTraversal
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerCharacter_RequestLinkedNodeTraversal final
{
public:
	class APhxTraversalNode*                      InNode;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_RequestLinkedNodeTraversal) == 0x000008, "Wrong alignment on PhxPlayerCharacter_RequestLinkedNodeTraversal");
static_assert(sizeof(PhxPlayerCharacter_RequestLinkedNodeTraversal) == 0x000008, "Wrong size on PhxPlayerCharacter_RequestLinkedNodeTraversal");
static_assert(offsetof(PhxPlayerCharacter_RequestLinkedNodeTraversal, InNode) == 0x000000, "Member 'PhxPlayerCharacter_RequestLinkedNodeTraversal::InNode' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.RequestMontageAttachStateEnter
// 0x0028 (0x0028 - 0x0000)
struct PhxPlayerCharacter_RequestMontageAttachStateEnter final
{
public:
	struct FPhxMontageAttachStateRequest          InRequest;                                         // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_RequestMontageAttachStateEnter) == 0x000008, "Wrong alignment on PhxPlayerCharacter_RequestMontageAttachStateEnter");
static_assert(sizeof(PhxPlayerCharacter_RequestMontageAttachStateEnter) == 0x000028, "Wrong size on PhxPlayerCharacter_RequestMontageAttachStateEnter");
static_assert(offsetof(PhxPlayerCharacter_RequestMontageAttachStateEnter, InRequest) == 0x000000, "Member 'PhxPlayerCharacter_RequestMontageAttachStateEnter::InRequest' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.RequestSoftCameraLookAt
// 0x0020 (0x0020 - 0x0000)
struct PhxPlayerCharacter_RequestSoftCameraLookAt final
{
public:
	class AActor*                                 TargetActor;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   TargetBone;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BlendInTime;                                       // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Duration;                                          // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         UninterruptableDuration;                           // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AbortDistance;                                     // 0x001C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_RequestSoftCameraLookAt) == 0x000008, "Wrong alignment on PhxPlayerCharacter_RequestSoftCameraLookAt");
static_assert(sizeof(PhxPlayerCharacter_RequestSoftCameraLookAt) == 0x000020, "Wrong size on PhxPlayerCharacter_RequestSoftCameraLookAt");
static_assert(offsetof(PhxPlayerCharacter_RequestSoftCameraLookAt, TargetActor) == 0x000000, "Member 'PhxPlayerCharacter_RequestSoftCameraLookAt::TargetActor' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestSoftCameraLookAt, TargetBone) == 0x000008, "Member 'PhxPlayerCharacter_RequestSoftCameraLookAt::TargetBone' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestSoftCameraLookAt, BlendInTime) == 0x000010, "Member 'PhxPlayerCharacter_RequestSoftCameraLookAt::BlendInTime' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestSoftCameraLookAt, Duration) == 0x000014, "Member 'PhxPlayerCharacter_RequestSoftCameraLookAt::Duration' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestSoftCameraLookAt, UninterruptableDuration) == 0x000018, "Member 'PhxPlayerCharacter_RequestSoftCameraLookAt::UninterruptableDuration' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_RequestSoftCameraLookAt, AbortDistance) == 0x00001C, "Member 'PhxPlayerCharacter_RequestSoftCameraLookAt::AbortDistance' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.SetCanOpenInventory
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerCharacter_SetCanOpenInventory final
{
public:
	bool                                          bSet;                                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_SetCanOpenInventory) == 0x000001, "Wrong alignment on PhxPlayerCharacter_SetCanOpenInventory");
static_assert(sizeof(PhxPlayerCharacter_SetCanOpenInventory) == 0x000001, "Wrong size on PhxPlayerCharacter_SetCanOpenInventory");
static_assert(offsetof(PhxPlayerCharacter_SetCanOpenInventory, bSet) == 0x000000, "Member 'PhxPlayerCharacter_SetCanOpenInventory::bSet' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.SetCanPlayerSprint
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerCharacter_SetCanPlayerSprint final
{
public:
	bool                                          bCanSprint;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_SetCanPlayerSprint) == 0x000001, "Wrong alignment on PhxPlayerCharacter_SetCanPlayerSprint");
static_assert(sizeof(PhxPlayerCharacter_SetCanPlayerSprint) == 0x000001, "Wrong size on PhxPlayerCharacter_SetCanPlayerSprint");
static_assert(offsetof(PhxPlayerCharacter_SetCanPlayerSprint, bCanSprint) == 0x000000, "Member 'PhxPlayerCharacter_SetCanPlayerSprint::bCanSprint' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.Teleport
// 0x0040 (0x0040 - 0x0000)
struct PhxPlayerCharacter_Teleport final
{
public:
	struct FTransform                             InTransform;                                       // 0x0000(0x0030)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bTeleportToFeetLocation;                           // 0x0030(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bResetControlRotation;                             // 0x0031(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_32[0xE];                                       // 0x0032(0x000E)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerCharacter_Teleport) == 0x000010, "Wrong alignment on PhxPlayerCharacter_Teleport");
static_assert(sizeof(PhxPlayerCharacter_Teleport) == 0x000040, "Wrong size on PhxPlayerCharacter_Teleport");
static_assert(offsetof(PhxPlayerCharacter_Teleport, InTransform) == 0x000000, "Member 'PhxPlayerCharacter_Teleport::InTransform' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_Teleport, bTeleportToFeetLocation) == 0x000030, "Member 'PhxPlayerCharacter_Teleport::bTeleportToFeetLocation' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_Teleport, bResetControlRotation) == 0x000031, "Member 'PhxPlayerCharacter_Teleport::bResetControlRotation' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.TeleportToCheckpoint
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerCharacter_TeleportToCheckpoint final
{
public:
	class ACheckpoint*                            Checkpoint;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_TeleportToCheckpoint) == 0x000008, "Wrong alignment on PhxPlayerCharacter_TeleportToCheckpoint");
static_assert(sizeof(PhxPlayerCharacter_TeleportToCheckpoint) == 0x000008, "Wrong size on PhxPlayerCharacter_TeleportToCheckpoint");
static_assert(offsetof(PhxPlayerCharacter_TeleportToCheckpoint, Checkpoint) == 0x000000, "Member 'PhxPlayerCharacter_TeleportToCheckpoint::Checkpoint' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.CanPlayerSprint
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerCharacter_CanPlayerSprint final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_CanPlayerSprint) == 0x000001, "Wrong alignment on PhxPlayerCharacter_CanPlayerSprint");
static_assert(sizeof(PhxPlayerCharacter_CanPlayerSprint) == 0x000001, "Wrong size on PhxPlayerCharacter_CanPlayerSprint");
static_assert(offsetof(PhxPlayerCharacter_CanPlayerSprint, ReturnValue) == 0x000000, "Member 'PhxPlayerCharacter_CanPlayerSprint::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.GetFlashlightSupplementalLights
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerCharacter_GetFlashlightSupplementalLights final
{
public:
	TArray<struct FPhxFlashlightSupplementalLightRegistrationData> OutLightComponents;               // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_GetFlashlightSupplementalLights) == 0x000008, "Wrong alignment on PhxPlayerCharacter_GetFlashlightSupplementalLights");
static_assert(sizeof(PhxPlayerCharacter_GetFlashlightSupplementalLights) == 0x000010, "Wrong size on PhxPlayerCharacter_GetFlashlightSupplementalLights");
static_assert(offsetof(PhxPlayerCharacter_GetFlashlightSupplementalLights, OutLightComponents) == 0x000000, "Member 'PhxPlayerCharacter_GetFlashlightSupplementalLights::OutLightComponents' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.GetGRPAttachmentPoint
// 0x0018 (0x0018 - 0x0000)
struct PhxPlayerCharacter_GetGRPAttachmentPoint final
{
public:
	struct FVector                                RelativePullAndHoldOffset;                         // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x000C(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_GetGRPAttachmentPoint) == 0x000004, "Wrong alignment on PhxPlayerCharacter_GetGRPAttachmentPoint");
static_assert(sizeof(PhxPlayerCharacter_GetGRPAttachmentPoint) == 0x000018, "Wrong size on PhxPlayerCharacter_GetGRPAttachmentPoint");
static_assert(offsetof(PhxPlayerCharacter_GetGRPAttachmentPoint, RelativePullAndHoldOffset) == 0x000000, "Member 'PhxPlayerCharacter_GetGRPAttachmentPoint::RelativePullAndHoldOffset' has a wrong offset!");
static_assert(offsetof(PhxPlayerCharacter_GetGRPAttachmentPoint, ReturnValue) == 0x00000C, "Member 'PhxPlayerCharacter_GetGRPAttachmentPoint::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.GetGRPAttachmentRotation
// 0x000C (0x000C - 0x0000)
struct PhxPlayerCharacter_GetGRPAttachmentRotation final
{
public:
	struct FRotator                               ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_GetGRPAttachmentRotation) == 0x000004, "Wrong alignment on PhxPlayerCharacter_GetGRPAttachmentRotation");
static_assert(sizeof(PhxPlayerCharacter_GetGRPAttachmentRotation) == 0x00000C, "Wrong size on PhxPlayerCharacter_GetGRPAttachmentRotation");
static_assert(offsetof(PhxPlayerCharacter_GetGRPAttachmentRotation, ReturnValue) == 0x000000, "Member 'PhxPlayerCharacter_GetGRPAttachmentRotation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.HasMoveDirection
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerCharacter_HasMoveDirection final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_HasMoveDirection) == 0x000001, "Wrong alignment on PhxPlayerCharacter_HasMoveDirection");
static_assert(sizeof(PhxPlayerCharacter_HasMoveDirection) == 0x000001, "Wrong size on PhxPlayerCharacter_HasMoveDirection");
static_assert(offsetof(PhxPlayerCharacter_HasMoveDirection, ReturnValue) == 0x000000, "Member 'PhxPlayerCharacter_HasMoveDirection::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerCharacter.IsInCombat
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerCharacter_IsInCombat final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerCharacter_IsInCombat) == 0x000001, "Wrong alignment on PhxPlayerCharacter_IsInCombat");
static_assert(sizeof(PhxPlayerCharacter_IsInCombat) == 0x000001, "Wrong size on PhxPlayerCharacter_IsInCombat");
static_assert(offsetof(PhxPlayerCharacter_IsInCombat, ReturnValue) == 0x000000, "Member 'PhxPlayerCharacter_IsInCombat::ReturnValue' has a wrong offset!");

// Function Phoenix.RecyclerWidget.ShowOutputMenu
// 0x000C (0x000C - 0x0000)
struct RecyclerWidget_ShowOutputMenu final
{
public:
	int32                                         numMetals;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         numBioplastics;                                    // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         numChemicals;                                      // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RecyclerWidget_ShowOutputMenu) == 0x000004, "Wrong alignment on RecyclerWidget_ShowOutputMenu");
static_assert(sizeof(RecyclerWidget_ShowOutputMenu) == 0x00000C, "Wrong size on RecyclerWidget_ShowOutputMenu");
static_assert(offsetof(RecyclerWidget_ShowOutputMenu, numMetals) == 0x000000, "Member 'RecyclerWidget_ShowOutputMenu::numMetals' has a wrong offset!");
static_assert(offsetof(RecyclerWidget_ShowOutputMenu, numBioplastics) == 0x000004, "Member 'RecyclerWidget_ShowOutputMenu::numBioplastics' has a wrong offset!");
static_assert(offsetof(RecyclerWidget_ShowOutputMenu, numChemicals) == 0x000008, "Member 'RecyclerWidget_ShowOutputMenu::numChemicals' has a wrong offset!");

// Function Phoenix.RecyclerWidget.ShowPreRecycleMenu
// 0x0004 (0x0004 - 0x0000)
struct RecyclerWidget_ShowPreRecycleMenu final
{
public:
	int32                                         numSalvage;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RecyclerWidget_ShowPreRecycleMenu) == 0x000004, "Wrong alignment on RecyclerWidget_ShowPreRecycleMenu");
static_assert(sizeof(RecyclerWidget_ShowPreRecycleMenu) == 0x000004, "Wrong size on RecyclerWidget_ShowPreRecycleMenu");
static_assert(offsetof(RecyclerWidget_ShowPreRecycleMenu, numSalvage) == 0x000000, "Member 'RecyclerWidget_ShowPreRecycleMenu::numSalvage' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.AddNewWidgetToViewport
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerControllerUIComponent_AddNewWidgetToViewport final
{
public:
	TSubclassOf<class UUserWidget>                WidgetClass;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UUserWidget*                            ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_AddNewWidgetToViewport) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_AddNewWidgetToViewport");
static_assert(sizeof(PhxPlayerControllerUIComponent_AddNewWidgetToViewport) == 0x000010, "Wrong size on PhxPlayerControllerUIComponent_AddNewWidgetToViewport");
static_assert(offsetof(PhxPlayerControllerUIComponent_AddNewWidgetToViewport, WidgetClass) == 0x000000, "Member 'PhxPlayerControllerUIComponent_AddNewWidgetToViewport::WidgetClass' has a wrong offset!");
static_assert(offsetof(PhxPlayerControllerUIComponent_AddNewWidgetToViewport, ReturnValue) == 0x000008, "Member 'PhxPlayerControllerUIComponent_AddNewWidgetToViewport::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetOutOfAmmoUI
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerControllerUIComponent_GetOutOfAmmoUI final
{
public:
	class USDSSimpleNotification*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetOutOfAmmoUI) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetOutOfAmmoUI");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetOutOfAmmoUI) == 0x000008, "Wrong size on PhxPlayerControllerUIComponent_GetOutOfAmmoUI");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetOutOfAmmoUI, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetOutOfAmmoUI::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.OnDialogueEnded
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerControllerUIComponent_OnDialogueEnded final
{
public:
	class UDialogue*                              Dialogue;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_OnDialogueEnded) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_OnDialogueEnded");
static_assert(sizeof(PhxPlayerControllerUIComponent_OnDialogueEnded) == 0x000008, "Wrong size on PhxPlayerControllerUIComponent_OnDialogueEnded");
static_assert(offsetof(PhxPlayerControllerUIComponent_OnDialogueEnded, Dialogue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_OnDialogueEnded::Dialogue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.OpenLevelFromMenu
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerControllerUIComponent_OpenLevelFromMenu final
{
public:
	int32                                         Index_0;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0004(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerControllerUIComponent_OpenLevelFromMenu) == 0x000004, "Wrong alignment on PhxPlayerControllerUIComponent_OpenLevelFromMenu");
static_assert(sizeof(PhxPlayerControllerUIComponent_OpenLevelFromMenu) == 0x000008, "Wrong size on PhxPlayerControllerUIComponent_OpenLevelFromMenu");
static_assert(offsetof(PhxPlayerControllerUIComponent_OpenLevelFromMenu, Index_0) == 0x000000, "Member 'PhxPlayerControllerUIComponent_OpenLevelFromMenu::Index_0' has a wrong offset!");
static_assert(offsetof(PhxPlayerControllerUIComponent_OpenLevelFromMenu, ReturnValue) == 0x000004, "Member 'PhxPlayerControllerUIComponent_OpenLevelFromMenu::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.RegisterAllLevelChunkDelegates
// 0x0020 (0x0020 - 0x0000)
struct PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates final
{
public:
	TDelegate<void(float Progress)>               ProgressDelegate;                                  // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(EChunkDelegateStatus Status)>  CompletionDelegate;                                // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates) == 0x000004, "Wrong alignment on PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates");
static_assert(sizeof(PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates) == 0x000020, "Wrong size on PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates");
static_assert(offsetof(PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates, ProgressDelegate) == 0x000000, "Member 'PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates::ProgressDelegate' has a wrong offset!");
static_assert(offsetof(PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates, CompletionDelegate) == 0x000010, "Member 'PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates::CompletionDelegate' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.RegisterLevelChunkDelegates
// 0x0024 (0x0024 - 0x0000)
struct PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates final
{
public:
	int32                                         LevelIndex;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(float Progress)>               ProgressDelegate;                                  // 0x0004(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(EChunkDelegateStatus Status)>  CompletionDelegate;                                // 0x0014(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates) == 0x000004, "Wrong alignment on PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates");
static_assert(sizeof(PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates) == 0x000024, "Wrong size on PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates");
static_assert(offsetof(PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates, LevelIndex) == 0x000000, "Member 'PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates::LevelIndex' has a wrong offset!");
static_assert(offsetof(PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates, ProgressDelegate) == 0x000004, "Member 'PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates::ProgressDelegate' has a wrong offset!");
static_assert(offsetof(PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates, CompletionDelegate) == 0x000014, "Member 'PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates::CompletionDelegate' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.RequestQuit
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerControllerUIComponent_RequestQuit final
{
public:
	bool                                          bForce;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_RequestQuit) == 0x000001, "Wrong alignment on PhxPlayerControllerUIComponent_RequestQuit");
static_assert(sizeof(PhxPlayerControllerUIComponent_RequestQuit) == 0x000001, "Wrong size on PhxPlayerControllerUIComponent_RequestQuit");
static_assert(offsetof(PhxPlayerControllerUIComponent_RequestQuit, bForce) == 0x000000, "Member 'PhxPlayerControllerUIComponent_RequestQuit::bForce' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.RequestUINotification
// 0x0128 (0x0128 - 0x0000)
struct PhxPlayerControllerUIComponent_RequestUINotification final
{
public:
	struct FNotificationData                      Notification;                                      // 0x0000(0x0128)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_RequestUINotification) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_RequestUINotification");
static_assert(sizeof(PhxPlayerControllerUIComponent_RequestUINotification) == 0x000128, "Wrong size on PhxPlayerControllerUIComponent_RequestUINotification");
static_assert(offsetof(PhxPlayerControllerUIComponent_RequestUINotification, Notification) == 0x000000, "Member 'PhxPlayerControllerUIComponent_RequestUINotification::Notification' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.SetRequestDeathScreen
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerControllerUIComponent_SetRequestDeathScreen final
{
public:
	bool                                          RequestDeath;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_SetRequestDeathScreen) == 0x000001, "Wrong alignment on PhxPlayerControllerUIComponent_SetRequestDeathScreen");
static_assert(sizeof(PhxPlayerControllerUIComponent_SetRequestDeathScreen) == 0x000001, "Wrong size on PhxPlayerControllerUIComponent_SetRequestDeathScreen");
static_assert(offsetof(PhxPlayerControllerUIComponent_SetRequestDeathScreen, RequestDeath) == 0x000000, "Member 'PhxPlayerControllerUIComponent_SetRequestDeathScreen::RequestDeath' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.SetRequestLogoScreen
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerControllerUIComponent_SetRequestLogoScreen final
{
public:
	bool                                          RequestLogo;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_SetRequestLogoScreen) == 0x000001, "Wrong alignment on PhxPlayerControllerUIComponent_SetRequestLogoScreen");
static_assert(sizeof(PhxPlayerControllerUIComponent_SetRequestLogoScreen) == 0x000001, "Wrong size on PhxPlayerControllerUIComponent_SetRequestLogoScreen");
static_assert(offsetof(PhxPlayerControllerUIComponent_SetRequestLogoScreen, RequestLogo) == 0x000000, "Member 'PhxPlayerControllerUIComponent_SetRequestLogoScreen::RequestLogo' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.SetRequestTransitionScreen
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerControllerUIComponent_SetRequestTransitionScreen final
{
public:
	bool                                          RequestTransition;                                 // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_SetRequestTransitionScreen) == 0x000001, "Wrong alignment on PhxPlayerControllerUIComponent_SetRequestTransitionScreen");
static_assert(sizeof(PhxPlayerControllerUIComponent_SetRequestTransitionScreen) == 0x000001, "Wrong size on PhxPlayerControllerUIComponent_SetRequestTransitionScreen");
static_assert(offsetof(PhxPlayerControllerUIComponent_SetRequestTransitionScreen, RequestTransition) == 0x000000, "Member 'PhxPlayerControllerUIComponent_SetRequestTransitionScreen::RequestTransition' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetActionForInputKey
// 0x0070 (0x0070 - 0x0000)
struct PhxPlayerControllerUIComponent_GetActionForInputKey final
{
public:
	EPhxInputKeys                                 InKey;                                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FActionMapKey                          ReturnValue;                                       // 0x0008(0x0068)(ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetActionForInputKey) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetActionForInputKey");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetActionForInputKey) == 0x000070, "Wrong size on PhxPlayerControllerUIComponent_GetActionForInputKey");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetActionForInputKey, InKey) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetActionForInputKey::InKey' has a wrong offset!");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetActionForInputKey, ReturnValue) == 0x000008, "Member 'PhxPlayerControllerUIComponent_GetActionForInputKey::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetControllerType
// 0x0001 (0x0001 - 0x0000)
struct PhxPlayerControllerUIComponent_GetControllerType final
{
public:
	EPhxControllerType                            ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetControllerType) == 0x000001, "Wrong alignment on PhxPlayerControllerUIComponent_GetControllerType");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetControllerType) == 0x000001, "Wrong size on PhxPlayerControllerUIComponent_GetControllerType");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetControllerType, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetControllerType::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetCurrentAudioLog
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerControllerUIComponent_GetCurrentAudioLog final
{
public:
	class UDialogue*                              ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetCurrentAudioLog) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetCurrentAudioLog");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetCurrentAudioLog) == 0x000008, "Wrong size on PhxPlayerControllerUIComponent_GetCurrentAudioLog");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetCurrentAudioLog, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetCurrentAudioLog::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetIconForKey
// 0x0020 (0x0020 - 0x0000)
struct PhxPlayerControllerUIComponent_GetIconForKey final
{
public:
	struct FKey                                   InKey;                                             // 0x0000(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxControllerKeys                            ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetIconForKey) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetIconForKey");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetIconForKey) == 0x000020, "Wrong size on PhxPlayerControllerUIComponent_GetIconForKey");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetIconForKey, InKey) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetIconForKey::InKey' has a wrong offset!");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetIconForKey, ReturnValue) == 0x000018, "Member 'PhxPlayerControllerUIComponent_GetIconForKey::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetInputKeyToActionMapping
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerControllerUIComponent_GetInputKeyToActionMapping final
{
public:
	class UPhxInputKeyToAction*                   ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetInputKeyToActionMapping) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetInputKeyToActionMapping");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetInputKeyToActionMapping) == 0x000008, "Wrong size on PhxPlayerControllerUIComponent_GetInputKeyToActionMapping");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetInputKeyToActionMapping, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetInputKeyToActionMapping::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetKeyToInputIconMapping
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerControllerUIComponent_GetKeyToInputIconMapping final
{
public:
	class UPhxKeyToControllerKey*                 ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetKeyToInputIconMapping) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetKeyToInputIconMapping");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetKeyToInputIconMapping) == 0x000008, "Wrong size on PhxPlayerControllerUIComponent_GetKeyToInputIconMapping");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetKeyToInputIconMapping, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetKeyToInputIconMapping::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetLevelNames
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerControllerUIComponent_GetLevelNames final
{
public:
	TArray<class FText>                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetLevelNames) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetLevelNames");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetLevelNames) == 0x000010, "Wrong size on PhxPlayerControllerUIComponent_GetLevelNames");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetLevelNames, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetLevelNames::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetLevelTags
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerControllerUIComponent_GetLevelTags final
{
public:
	TArray<struct FGameplayTag>                   ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetLevelTags) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetLevelTags");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetLevelTags) == 0x000010, "Wrong size on PhxPlayerControllerUIComponent_GetLevelTags");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetLevelTags, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetLevelTags::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetLevelTransitionAssets
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerControllerUIComponent_GetLevelTransitionAssets final
{
public:
	TArray<class ULevelTransitionDataAsset*>      ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetLevelTransitionAssets) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetLevelTransitionAssets");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetLevelTransitionAssets) == 0x000010, "Wrong size on PhxPlayerControllerUIComponent_GetLevelTransitionAssets");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetLevelTransitionAssets, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetLevelTransitionAssets::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetMenuTransitionAsset
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerControllerUIComponent_GetMenuTransitionAsset final
{
public:
	const class ULevelTransitionDataAsset*        ReturnValue;                                       // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetMenuTransitionAsset) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetMenuTransitionAsset");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetMenuTransitionAsset) == 0x000008, "Wrong size on PhxPlayerControllerUIComponent_GetMenuTransitionAsset");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetMenuTransitionAsset, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetMenuTransitionAsset::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerControllerUIComponent.GetPlatformTexturePack
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerControllerUIComponent_GetPlatformTexturePack final
{
public:
	class UPhxPlatformTexturePack*                ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerControllerUIComponent_GetPlatformTexturePack) == 0x000008, "Wrong alignment on PhxPlayerControllerUIComponent_GetPlatformTexturePack");
static_assert(sizeof(PhxPlayerControllerUIComponent_GetPlatformTexturePack) == 0x000008, "Wrong size on PhxPlayerControllerUIComponent_GetPlatformTexturePack");
static_assert(offsetof(PhxPlayerControllerUIComponent_GetPlatformTexturePack, ReturnValue) == 0x000000, "Member 'PhxPlayerControllerUIComponent_GetPlatformTexturePack::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerMovementComponent.RequestPipeSlideAlignment
// 0x001C (0x001C - 0x0000)
struct PhxPlayerMovementComponent_RequestPipeSlideAlignment final
{
public:
	float                                         TargetSpeed;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                TargetPos;                                         // 0x0004(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               TargetRot;                                         // 0x0010(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerMovementComponent_RequestPipeSlideAlignment) == 0x000004, "Wrong alignment on PhxPlayerMovementComponent_RequestPipeSlideAlignment");
static_assert(sizeof(PhxPlayerMovementComponent_RequestPipeSlideAlignment) == 0x00001C, "Wrong size on PhxPlayerMovementComponent_RequestPipeSlideAlignment");
static_assert(offsetof(PhxPlayerMovementComponent_RequestPipeSlideAlignment, TargetSpeed) == 0x000000, "Member 'PhxPlayerMovementComponent_RequestPipeSlideAlignment::TargetSpeed' has a wrong offset!");
static_assert(offsetof(PhxPlayerMovementComponent_RequestPipeSlideAlignment, TargetPos) == 0x000004, "Member 'PhxPlayerMovementComponent_RequestPipeSlideAlignment::TargetPos' has a wrong offset!");
static_assert(offsetof(PhxPlayerMovementComponent_RequestPipeSlideAlignment, TargetRot) == 0x000010, "Member 'PhxPlayerMovementComponent_RequestPipeSlideAlignment::TargetRot' has a wrong offset!");

// Function Phoenix.PhxPlayerState.GetHitCounter
// 0x0008 (0x0008 - 0x0000)
struct PhxPlayerState_GetHitCounter final
{
public:
	class UHitCounter*                            ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerState_GetHitCounter) == 0x000008, "Wrong alignment on PhxPlayerState_GetHitCounter");
static_assert(sizeof(PhxPlayerState_GetHitCounter) == 0x000008, "Wrong size on PhxPlayerState_GetHitCounter");
static_assert(offsetof(PhxPlayerState_GetHitCounter, ReturnValue) == 0x000000, "Member 'PhxPlayerState_GetHitCounter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxPlayerTriggerCapsule.HandleActorBeginOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerTriggerCapsule_HandleActorBeginOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerTriggerCapsule_HandleActorBeginOverlap) == 0x000008, "Wrong alignment on PhxPlayerTriggerCapsule_HandleActorBeginOverlap");
static_assert(sizeof(PhxPlayerTriggerCapsule_HandleActorBeginOverlap) == 0x000010, "Wrong size on PhxPlayerTriggerCapsule_HandleActorBeginOverlap");
static_assert(offsetof(PhxPlayerTriggerCapsule_HandleActorBeginOverlap, OverlappedActor) == 0x000000, "Member 'PhxPlayerTriggerCapsule_HandleActorBeginOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxPlayerTriggerCapsule_HandleActorBeginOverlap, OtherActor) == 0x000008, "Member 'PhxPlayerTriggerCapsule_HandleActorBeginOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxPlayerTriggerCapsule.HandleActorEndOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerTriggerCapsule_HandleActorEndOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerTriggerCapsule_HandleActorEndOverlap) == 0x000008, "Wrong alignment on PhxPlayerTriggerCapsule_HandleActorEndOverlap");
static_assert(sizeof(PhxPlayerTriggerCapsule_HandleActorEndOverlap) == 0x000010, "Wrong size on PhxPlayerTriggerCapsule_HandleActorEndOverlap");
static_assert(offsetof(PhxPlayerTriggerCapsule_HandleActorEndOverlap, OverlappedActor) == 0x000000, "Member 'PhxPlayerTriggerCapsule_HandleActorEndOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxPlayerTriggerCapsule_HandleActorEndOverlap, OtherActor) == 0x000008, "Member 'PhxPlayerTriggerCapsule_HandleActorEndOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxPlayerTriggerSphere.HandleActorBeginOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerTriggerSphere_HandleActorBeginOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerTriggerSphere_HandleActorBeginOverlap) == 0x000008, "Wrong alignment on PhxPlayerTriggerSphere_HandleActorBeginOverlap");
static_assert(sizeof(PhxPlayerTriggerSphere_HandleActorBeginOverlap) == 0x000010, "Wrong size on PhxPlayerTriggerSphere_HandleActorBeginOverlap");
static_assert(offsetof(PhxPlayerTriggerSphere_HandleActorBeginOverlap, OverlappedActor) == 0x000000, "Member 'PhxPlayerTriggerSphere_HandleActorBeginOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxPlayerTriggerSphere_HandleActorBeginOverlap, OtherActor) == 0x000008, "Member 'PhxPlayerTriggerSphere_HandleActorBeginOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxPlayerTriggerSphere.HandleActorEndOverlap
// 0x0010 (0x0010 - 0x0000)
struct PhxPlayerTriggerSphere_HandleActorEndOverlap final
{
public:
	class AActor*                                 OverlappedActor;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPlayerTriggerSphere_HandleActorEndOverlap) == 0x000008, "Wrong alignment on PhxPlayerTriggerSphere_HandleActorEndOverlap");
static_assert(sizeof(PhxPlayerTriggerSphere_HandleActorEndOverlap) == 0x000010, "Wrong size on PhxPlayerTriggerSphere_HandleActorEndOverlap");
static_assert(offsetof(PhxPlayerTriggerSphere_HandleActorEndOverlap, OverlappedActor) == 0x000000, "Member 'PhxPlayerTriggerSphere_HandleActorEndOverlap::OverlappedActor' has a wrong offset!");
static_assert(offsetof(PhxPlayerTriggerSphere_HandleActorEndOverlap, OtherActor) == 0x000008, "Member 'PhxPlayerTriggerSphere_HandleActorEndOverlap::OtherActor' has a wrong offset!");

// Function Phoenix.PhxPPEImpactListenerInterface.OnImpactedByEnemy
// 0x0010 (0x0010 - 0x0000)
struct PhxPPEImpactListenerInterface_OnImpactedByEnemy final
{
public:
	class UPrimitiveComponent*                    ImpactedComponent;                                 // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        ImpactedByEnemy;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPPEImpactListenerInterface_OnImpactedByEnemy) == 0x000008, "Wrong alignment on PhxPPEImpactListenerInterface_OnImpactedByEnemy");
static_assert(sizeof(PhxPPEImpactListenerInterface_OnImpactedByEnemy) == 0x000010, "Wrong size on PhxPPEImpactListenerInterface_OnImpactedByEnemy");
static_assert(offsetof(PhxPPEImpactListenerInterface_OnImpactedByEnemy, ImpactedComponent) == 0x000000, "Member 'PhxPPEImpactListenerInterface_OnImpactedByEnemy::ImpactedComponent' has a wrong offset!");
static_assert(offsetof(PhxPPEImpactListenerInterface_OnImpactedByEnemy, ImpactedByEnemy) == 0x000008, "Member 'PhxPPEImpactListenerInterface_OnImpactedByEnemy::ImpactedByEnemy' has a wrong offset!");

// Function Phoenix.PhxPPEInteractionInterface.OnHitByPPE
// 0x0020 (0x0020 - 0x0000)
struct PhxPPEInteractionInterface_OnHitByPPE final
{
public:
	EPPEProjectileType                            PPEProjectileType;                                 // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                ShotDirection;                                     // 0x0004(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ShotPower;                                         // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ImpactNormal;                                      // 0x0014(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPPEInteractionInterface_OnHitByPPE) == 0x000004, "Wrong alignment on PhxPPEInteractionInterface_OnHitByPPE");
static_assert(sizeof(PhxPPEInteractionInterface_OnHitByPPE) == 0x000020, "Wrong size on PhxPPEInteractionInterface_OnHitByPPE");
static_assert(offsetof(PhxPPEInteractionInterface_OnHitByPPE, PPEProjectileType) == 0x000000, "Member 'PhxPPEInteractionInterface_OnHitByPPE::PPEProjectileType' has a wrong offset!");
static_assert(offsetof(PhxPPEInteractionInterface_OnHitByPPE, ShotDirection) == 0x000004, "Member 'PhxPPEInteractionInterface_OnHitByPPE::ShotDirection' has a wrong offset!");
static_assert(offsetof(PhxPPEInteractionInterface_OnHitByPPE, ShotPower) == 0x000010, "Member 'PhxPPEInteractionInterface_OnHitByPPE::ShotPower' has a wrong offset!");
static_assert(offsetof(PhxPPEInteractionInterface_OnHitByPPE, ImpactNormal) == 0x000014, "Member 'PhxPPEInteractionInterface_OnHitByPPE::ImpactNormal' has a wrong offset!");

// Function Phoenix.PhxPrevizVideo.IsPlaying
// 0x0001 (0x0001 - 0x0000)
struct PhxPrevizVideo_IsPlaying final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxPrevizVideo_IsPlaying) == 0x000001, "Wrong alignment on PhxPrevizVideo_IsPlaying");
static_assert(sizeof(PhxPrevizVideo_IsPlaying) == 0x000001, "Wrong size on PhxPrevizVideo_IsPlaying");
static_assert(offsetof(PhxPrevizVideo_IsPlaying, ReturnValue) == 0x000000, "Member 'PhxPrevizVideo_IsPlaying::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.AddTag
// 0x000C (0x000C - 0x0000)
struct PhxWorldStateData_AddTag final
{
public:
	struct FGameplayTag                           Tag;                                               // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxWorldStateData_AddTag) == 0x000004, "Wrong alignment on PhxWorldStateData_AddTag");
static_assert(sizeof(PhxWorldStateData_AddTag) == 0x00000C, "Wrong size on PhxWorldStateData_AddTag");
static_assert(offsetof(PhxWorldStateData_AddTag, Tag) == 0x000000, "Member 'PhxWorldStateData_AddTag::Tag' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_AddTag, ReturnValue) == 0x000008, "Member 'PhxWorldStateData_AddTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.ClearCounter
// 0x000C (0x000C - 0x0000)
struct PhxWorldStateData_ClearCounter final
{
public:
	struct FGameplayTag                           Counter;                                           // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxWorldStateData_ClearCounter) == 0x000004, "Wrong alignment on PhxWorldStateData_ClearCounter");
static_assert(sizeof(PhxWorldStateData_ClearCounter) == 0x00000C, "Wrong size on PhxWorldStateData_ClearCounter");
static_assert(offsetof(PhxWorldStateData_ClearCounter, Counter) == 0x000000, "Member 'PhxWorldStateData_ClearCounter::Counter' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_ClearCounter, ReturnValue) == 0x000008, "Member 'PhxWorldStateData_ClearCounter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.DecrementCounter
// 0x000C (0x000C - 0x0000)
struct PhxWorldStateData_DecrementCounter final
{
public:
	struct FGameplayTag                           Counter;                                           // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldStateData_DecrementCounter) == 0x000004, "Wrong alignment on PhxWorldStateData_DecrementCounter");
static_assert(sizeof(PhxWorldStateData_DecrementCounter) == 0x00000C, "Wrong size on PhxWorldStateData_DecrementCounter");
static_assert(offsetof(PhxWorldStateData_DecrementCounter, Counter) == 0x000000, "Member 'PhxWorldStateData_DecrementCounter::Counter' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_DecrementCounter, ReturnValue) == 0x000008, "Member 'PhxWorldStateData_DecrementCounter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.FindAnyWithParentTag
// 0x0010 (0x0010 - 0x0000)
struct PhxWorldStateData_FindAnyWithParentTag final
{
public:
	struct FGameplayTag                           ParentTag;                                         // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldStateData_FindAnyWithParentTag) == 0x000004, "Wrong alignment on PhxWorldStateData_FindAnyWithParentTag");
static_assert(sizeof(PhxWorldStateData_FindAnyWithParentTag) == 0x000010, "Wrong size on PhxWorldStateData_FindAnyWithParentTag");
static_assert(offsetof(PhxWorldStateData_FindAnyWithParentTag, ParentTag) == 0x000000, "Member 'PhxWorldStateData_FindAnyWithParentTag::ParentTag' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_FindAnyWithParentTag, ReturnValue) == 0x000008, "Member 'PhxWorldStateData_FindAnyWithParentTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.IncrementCounter
// 0x000C (0x000C - 0x0000)
struct PhxWorldStateData_IncrementCounter final
{
public:
	struct FGameplayTag                           Counter;                                           // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldStateData_IncrementCounter) == 0x000004, "Wrong alignment on PhxWorldStateData_IncrementCounter");
static_assert(sizeof(PhxWorldStateData_IncrementCounter) == 0x00000C, "Wrong size on PhxWorldStateData_IncrementCounter");
static_assert(offsetof(PhxWorldStateData_IncrementCounter, Counter) == 0x000000, "Member 'PhxWorldStateData_IncrementCounter::Counter' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_IncrementCounter, ReturnValue) == 0x000008, "Member 'PhxWorldStateData_IncrementCounter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.RemoveAnyWithParentTag
// 0x000C (0x000C - 0x0000)
struct PhxWorldStateData_RemoveAnyWithParentTag final
{
public:
	struct FGameplayTag                           ParentTag;                                         // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxWorldStateData_RemoveAnyWithParentTag) == 0x000004, "Wrong alignment on PhxWorldStateData_RemoveAnyWithParentTag");
static_assert(sizeof(PhxWorldStateData_RemoveAnyWithParentTag) == 0x00000C, "Wrong size on PhxWorldStateData_RemoveAnyWithParentTag");
static_assert(offsetof(PhxWorldStateData_RemoveAnyWithParentTag, ParentTag) == 0x000000, "Member 'PhxWorldStateData_RemoveAnyWithParentTag::ParentTag' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_RemoveAnyWithParentTag, ReturnValue) == 0x000008, "Member 'PhxWorldStateData_RemoveAnyWithParentTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.RemoveTag
// 0x000C (0x000C - 0x0000)
struct PhxWorldStateData_RemoveTag final
{
public:
	struct FGameplayTag                           Tag;                                               // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxWorldStateData_RemoveTag) == 0x000004, "Wrong alignment on PhxWorldStateData_RemoveTag");
static_assert(sizeof(PhxWorldStateData_RemoveTag) == 0x00000C, "Wrong size on PhxWorldStateData_RemoveTag");
static_assert(offsetof(PhxWorldStateData_RemoveTag, Tag) == 0x000000, "Member 'PhxWorldStateData_RemoveTag::Tag' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_RemoveTag, ReturnValue) == 0x000008, "Member 'PhxWorldStateData_RemoveTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.SetCounter
// 0x0010 (0x0010 - 0x0000)
struct PhxWorldStateData_SetCounter final
{
public:
	struct FGameplayTag                           Counter;                                           // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Value;                                             // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x000C(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldStateData_SetCounter) == 0x000004, "Wrong alignment on PhxWorldStateData_SetCounter");
static_assert(sizeof(PhxWorldStateData_SetCounter) == 0x000010, "Wrong size on PhxWorldStateData_SetCounter");
static_assert(offsetof(PhxWorldStateData_SetCounter, Counter) == 0x000000, "Member 'PhxWorldStateData_SetCounter::Counter' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_SetCounter, Value) == 0x000008, "Member 'PhxWorldStateData_SetCounter::Value' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_SetCounter, ReturnValue) == 0x00000C, "Member 'PhxWorldStateData_SetCounter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.GetCounterValue
// 0x000C (0x000C - 0x0000)
struct PhxWorldStateData_GetCounterValue final
{
public:
	struct FGameplayTag                           Counter;                                           // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldStateData_GetCounterValue) == 0x000004, "Wrong alignment on PhxWorldStateData_GetCounterValue");
static_assert(sizeof(PhxWorldStateData_GetCounterValue) == 0x00000C, "Wrong size on PhxWorldStateData_GetCounterValue");
static_assert(offsetof(PhxWorldStateData_GetCounterValue, Counter) == 0x000000, "Member 'PhxWorldStateData_GetCounterValue::Counter' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_GetCounterValue, ReturnValue) == 0x000008, "Member 'PhxWorldStateData_GetCounterValue::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldStateData.QueryTag
// 0x000C (0x000C - 0x0000)
struct PhxWorldStateData_QueryTag final
{
public:
	struct FGameplayTag                           Tag;                                               // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxWorldStateData_QueryTag) == 0x000004, "Wrong alignment on PhxWorldStateData_QueryTag");
static_assert(sizeof(PhxWorldStateData_QueryTag) == 0x00000C, "Wrong size on PhxWorldStateData_QueryTag");
static_assert(offsetof(PhxWorldStateData_QueryTag, Tag) == 0x000000, "Member 'PhxWorldStateData_QueryTag::Tag' has a wrong offset!");
static_assert(offsetof(PhxWorldStateData_QueryTag, ReturnValue) == 0x000008, "Member 'PhxWorldStateData_QueryTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.AddProgressionStatusTag
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_AddProgressionStatusTag final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ProgressionTag;                                    // 0x0008(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_AddProgressionStatusTag) == 0x000008, "Wrong alignment on PhxProgressManager_AddProgressionStatusTag");
static_assert(sizeof(PhxProgressManager_AddProgressionStatusTag) == 0x000010, "Wrong size on PhxProgressManager_AddProgressionStatusTag");
static_assert(offsetof(PhxProgressManager_AddProgressionStatusTag, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_AddProgressionStatusTag::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_AddProgressionStatusTag, ProgressionTag) == 0x000008, "Member 'PhxProgressManager_AddProgressionStatusTag::ProgressionTag' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetCurrentLevelTags
// 0x0028 (0x0028 - 0x0000)
struct PhxProgressManager_GetCurrentLevelTags final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTagContainer                  ReturnValue;                                       // 0x0008(0x0020)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_GetCurrentLevelTags) == 0x000008, "Wrong alignment on PhxProgressManager_GetCurrentLevelTags");
static_assert(sizeof(PhxProgressManager_GetCurrentLevelTags) == 0x000028, "Wrong size on PhxProgressManager_GetCurrentLevelTags");
static_assert(offsetof(PhxProgressManager_GetCurrentLevelTags, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetCurrentLevelTags::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetCurrentLevelTags, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetCurrentLevelTags::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetCurrentLevelWorldState
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetCurrentLevelWorldState final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxWorldStateData*                     ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_GetCurrentLevelWorldState) == 0x000008, "Wrong alignment on PhxProgressManager_GetCurrentLevelWorldState");
static_assert(sizeof(PhxProgressManager_GetCurrentLevelWorldState) == 0x000010, "Wrong size on PhxProgressManager_GetCurrentLevelWorldState");
static_assert(offsetof(PhxProgressManager_GetCurrentLevelWorldState, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetCurrentLevelWorldState::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetCurrentLevelWorldState, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetCurrentLevelWorldState::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetCurrentObjective
// 0x0058 (0x0058 - 0x0000)
struct PhxProgressManager_GetCurrentObjective final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FPhxObjective                          ReturnValue;                                       // 0x0008(0x0050)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_GetCurrentObjective) == 0x000008, "Wrong alignment on PhxProgressManager_GetCurrentObjective");
static_assert(sizeof(PhxProgressManager_GetCurrentObjective) == 0x000058, "Wrong size on PhxProgressManager_GetCurrentObjective");
static_assert(offsetof(PhxProgressManager_GetCurrentObjective, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetCurrentObjective::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetCurrentObjective, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetCurrentObjective::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetDifficulty
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetDifficulty final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxDifficultyLevel                           ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_GetDifficulty) == 0x000008, "Wrong alignment on PhxProgressManager_GetDifficulty");
static_assert(sizeof(PhxProgressManager_GetDifficulty) == 0x000010, "Wrong size on PhxProgressManager_GetDifficulty");
static_assert(offsetof(PhxProgressManager_GetDifficulty, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetDifficulty::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetDifficulty, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetDifficulty::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetDLCStoryCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetDLCStoryCompleted final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_GetDLCStoryCompleted) == 0x000008, "Wrong alignment on PhxProgressManager_GetDLCStoryCompleted");
static_assert(sizeof(PhxProgressManager_GetDLCStoryCompleted) == 0x000010, "Wrong size on PhxProgressManager_GetDLCStoryCompleted");
static_assert(offsetof(PhxProgressManager_GetDLCStoryCompleted, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetDLCStoryCompleted::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetDLCStoryCompleted, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetDLCStoryCompleted::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetGlobalWorldState
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetGlobalWorldState final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxWorldStateData*                     ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_GetGlobalWorldState) == 0x000008, "Wrong alignment on PhxProgressManager_GetGlobalWorldState");
static_assert(sizeof(PhxProgressManager_GetGlobalWorldState) == 0x000010, "Wrong size on PhxProgressManager_GetGlobalWorldState");
static_assert(offsetof(PhxProgressManager_GetGlobalWorldState, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetGlobalWorldState::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetGlobalWorldState, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetGlobalWorldState::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetLastCheckpointTimeStamp
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetLastCheckpointTimeStamp final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FDateTime                              ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_GetLastCheckpointTimeStamp) == 0x000008, "Wrong alignment on PhxProgressManager_GetLastCheckpointTimeStamp");
static_assert(sizeof(PhxProgressManager_GetLastCheckpointTimeStamp) == 0x000010, "Wrong size on PhxProgressManager_GetLastCheckpointTimeStamp");
static_assert(offsetof(PhxProgressManager_GetLastCheckpointTimeStamp, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetLastCheckpointTimeStamp::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetLastCheckpointTimeStamp, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetLastCheckpointTimeStamp::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetMainStoryCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetMainStoryCompleted final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_GetMainStoryCompleted) == 0x000008, "Wrong alignment on PhxProgressManager_GetMainStoryCompleted");
static_assert(sizeof(PhxProgressManager_GetMainStoryCompleted) == 0x000010, "Wrong size on PhxProgressManager_GetMainStoryCompleted");
static_assert(offsetof(PhxProgressManager_GetMainStoryCompleted, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetMainStoryCompleted::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetMainStoryCompleted, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetMainStoryCompleted::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetManagerState
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetManagerState final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxProgressManagerState                      ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_GetManagerState) == 0x000008, "Wrong alignment on PhxProgressManager_GetManagerState");
static_assert(sizeof(PhxProgressManager_GetManagerState) == 0x000010, "Wrong size on PhxProgressManager_GetManagerState");
static_assert(offsetof(PhxProgressManager_GetManagerState, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetManagerState::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetManagerState, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetManagerState::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetNewGamePlus
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetNewGamePlus final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_GetNewGamePlus) == 0x000008, "Wrong alignment on PhxProgressManager_GetNewGamePlus");
static_assert(sizeof(PhxProgressManager_GetNewGamePlus) == 0x000010, "Wrong size on PhxProgressManager_GetNewGamePlus");
static_assert(offsetof(PhxProgressManager_GetNewGamePlus, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetNewGamePlus::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetNewGamePlus, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetNewGamePlus::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetPersistentLevelWorldState
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetPersistentLevelWorldState final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxWorldStateData*                     ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_GetPersistentLevelWorldState) == 0x000008, "Wrong alignment on PhxProgressManager_GetPersistentLevelWorldState");
static_assert(sizeof(PhxProgressManager_GetPersistentLevelWorldState) == 0x000010, "Wrong size on PhxProgressManager_GetPersistentLevelWorldState");
static_assert(offsetof(PhxProgressManager_GetPersistentLevelWorldState, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetPersistentLevelWorldState::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetPersistentLevelWorldState, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetPersistentLevelWorldState::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetPreviousLevelTags
// 0x0028 (0x0028 - 0x0000)
struct PhxProgressManager_GetPreviousLevelTags final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTagContainer                  ReturnValue;                                       // 0x0008(0x0020)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_GetPreviousLevelTags) == 0x000008, "Wrong alignment on PhxProgressManager_GetPreviousLevelTags");
static_assert(sizeof(PhxProgressManager_GetPreviousLevelTags) == 0x000028, "Wrong size on PhxProgressManager_GetPreviousLevelTags");
static_assert(offsetof(PhxProgressManager_GetPreviousLevelTags, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetPreviousLevelTags::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetPreviousLevelTags, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetPreviousLevelTags::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetProgressionStatusTags
// 0x0030 (0x0030 - 0x0000)
struct PhxProgressManager_GetProgressionStatusTags final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bProgressionTagsOnly;                              // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTagContainer                  ReturnValue;                                       // 0x0010(0x0020)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_GetProgressionStatusTags) == 0x000008, "Wrong alignment on PhxProgressManager_GetProgressionStatusTags");
static_assert(sizeof(PhxProgressManager_GetProgressionStatusTags) == 0x000030, "Wrong size on PhxProgressManager_GetProgressionStatusTags");
static_assert(offsetof(PhxProgressManager_GetProgressionStatusTags, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetProgressionStatusTags::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetProgressionStatusTags, bProgressionTagsOnly) == 0x000008, "Member 'PhxProgressManager_GetProgressionStatusTags::bProgressionTagsOnly' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetProgressionStatusTags, ReturnValue) == 0x000010, "Member 'PhxProgressManager_GetProgressionStatusTags::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetStoryDLC
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetStoryDLC final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_GetStoryDLC) == 0x000008, "Wrong alignment on PhxProgressManager_GetStoryDLC");
static_assert(sizeof(PhxProgressManager_GetStoryDLC) == 0x000010, "Wrong size on PhxProgressManager_GetStoryDLC");
static_assert(offsetof(PhxProgressManager_GetStoryDLC, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetStoryDLC::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetStoryDLC, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetStoryDLC::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GetTotalTimePlayed
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_GetTotalTimePlayed final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_GetTotalTimePlayed) == 0x000008, "Wrong alignment on PhxProgressManager_GetTotalTimePlayed");
static_assert(sizeof(PhxProgressManager_GetTotalTimePlayed) == 0x000010, "Wrong size on PhxProgressManager_GetTotalTimePlayed");
static_assert(offsetof(PhxProgressManager_GetTotalTimePlayed, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_GetTotalTimePlayed::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_GetTotalTimePlayed, ReturnValue) == 0x000008, "Member 'PhxProgressManager_GetTotalTimePlayed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.HasCurrentObjective
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_HasCurrentObjective final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_HasCurrentObjective) == 0x000008, "Wrong alignment on PhxProgressManager_HasCurrentObjective");
static_assert(sizeof(PhxProgressManager_HasCurrentObjective) == 0x000010, "Wrong size on PhxProgressManager_HasCurrentObjective");
static_assert(offsetof(PhxProgressManager_HasCurrentObjective, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_HasCurrentObjective::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_HasCurrentObjective, ReturnValue) == 0x000008, "Member 'PhxProgressManager_HasCurrentObjective::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.HasLastCheckpoint
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_HasLastCheckpoint final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_HasLastCheckpoint) == 0x000008, "Wrong alignment on PhxProgressManager_HasLastCheckpoint");
static_assert(sizeof(PhxProgressManager_HasLastCheckpoint) == 0x000010, "Wrong size on PhxProgressManager_HasLastCheckpoint");
static_assert(offsetof(PhxProgressManager_HasLastCheckpoint, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_HasLastCheckpoint::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_HasLastCheckpoint, ReturnValue) == 0x000008, "Member 'PhxProgressManager_HasLastCheckpoint::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.HideSubObjective
// 0x0008 (0x0008 - 0x0000)
struct PhxProgressManager_HideSubObjective final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_HideSubObjective) == 0x000008, "Wrong alignment on PhxProgressManager_HideSubObjective");
static_assert(sizeof(PhxProgressManager_HideSubObjective) == 0x000008, "Wrong size on PhxProgressManager_HideSubObjective");
static_assert(offsetof(PhxProgressManager_HideSubObjective, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_HideSubObjective::WorldContextObject' has a wrong offset!");

// Function Phoenix.PhxProgressManager.InitSessionStartTime
// 0x0008 (0x0008 - 0x0000)
struct PhxProgressManager_InitSessionStartTime final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_InitSessionStartTime) == 0x000008, "Wrong alignment on PhxProgressManager_InitSessionStartTime");
static_assert(sizeof(PhxProgressManager_InitSessionStartTime) == 0x000008, "Wrong size on PhxProgressManager_InitSessionStartTime");
static_assert(offsetof(PhxProgressManager_InitSessionStartTime, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_InitSessionStartTime::WorldContextObject' has a wrong offset!");

// Function Phoenix.PhxProgressManager.IsRestoringFromCheckpoint
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_IsRestoringFromCheckpoint final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_IsRestoringFromCheckpoint) == 0x000008, "Wrong alignment on PhxProgressManager_IsRestoringFromCheckpoint");
static_assert(sizeof(PhxProgressManager_IsRestoringFromCheckpoint) == 0x000010, "Wrong size on PhxProgressManager_IsRestoringFromCheckpoint");
static_assert(offsetof(PhxProgressManager_IsRestoringFromCheckpoint, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_IsRestoringFromCheckpoint::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_IsRestoringFromCheckpoint, ReturnValue) == 0x000008, "Member 'PhxProgressManager_IsRestoringFromCheckpoint::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProgressManager.RemoveProgressionStatusTags
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_RemoveProgressionStatusTags final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ProgressionTag;                                    // 0x0008(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_RemoveProgressionStatusTags) == 0x000008, "Wrong alignment on PhxProgressManager_RemoveProgressionStatusTags");
static_assert(sizeof(PhxProgressManager_RemoveProgressionStatusTags) == 0x000010, "Wrong size on PhxProgressManager_RemoveProgressionStatusTags");
static_assert(offsetof(PhxProgressManager_RemoveProgressionStatusTags, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_RemoveProgressionStatusTags::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_RemoveProgressionStatusTags, ProgressionTag) == 0x000008, "Member 'PhxProgressManager_RemoveProgressionStatusTags::ProgressionTag' has a wrong offset!");

// Function Phoenix.PhxProgressManager.RestoreLastCheckpointFromContext
// 0x0008 (0x0008 - 0x0000)
struct PhxProgressManager_RestoreLastCheckpointFromContext final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_RestoreLastCheckpointFromContext) == 0x000008, "Wrong alignment on PhxProgressManager_RestoreLastCheckpointFromContext");
static_assert(sizeof(PhxProgressManager_RestoreLastCheckpointFromContext) == 0x000008, "Wrong size on PhxProgressManager_RestoreLastCheckpointFromContext");
static_assert(offsetof(PhxProgressManager_RestoreLastCheckpointFromContext, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_RestoreLastCheckpointFromContext::WorldContextObject' has a wrong offset!");

// Function Phoenix.PhxProgressManager.SetDifficulty
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_SetDifficulty final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhxDifficultyLevel                           Difficulty;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_SetDifficulty) == 0x000008, "Wrong alignment on PhxProgressManager_SetDifficulty");
static_assert(sizeof(PhxProgressManager_SetDifficulty) == 0x000010, "Wrong size on PhxProgressManager_SetDifficulty");
static_assert(offsetof(PhxProgressManager_SetDifficulty, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_SetDifficulty::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_SetDifficulty, Difficulty) == 0x000008, "Member 'PhxProgressManager_SetDifficulty::Difficulty' has a wrong offset!");

// Function Phoenix.PhxProgressManager.SetDLCStoryCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_SetDLCStoryCompleted final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCompleted;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_SetDLCStoryCompleted) == 0x000008, "Wrong alignment on PhxProgressManager_SetDLCStoryCompleted");
static_assert(sizeof(PhxProgressManager_SetDLCStoryCompleted) == 0x000010, "Wrong size on PhxProgressManager_SetDLCStoryCompleted");
static_assert(offsetof(PhxProgressManager_SetDLCStoryCompleted, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_SetDLCStoryCompleted::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_SetDLCStoryCompleted, bCompleted) == 0x000008, "Member 'PhxProgressManager_SetDLCStoryCompleted::bCompleted' has a wrong offset!");

// Function Phoenix.PhxProgressManager.SetMainStoryCompleted
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_SetMainStoryCompleted final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCompleted;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_SetMainStoryCompleted) == 0x000008, "Wrong alignment on PhxProgressManager_SetMainStoryCompleted");
static_assert(sizeof(PhxProgressManager_SetMainStoryCompleted) == 0x000010, "Wrong size on PhxProgressManager_SetMainStoryCompleted");
static_assert(offsetof(PhxProgressManager_SetMainStoryCompleted, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_SetMainStoryCompleted::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_SetMainStoryCompleted, bCompleted) == 0x000008, "Member 'PhxProgressManager_SetMainStoryCompleted::bCompleted' has a wrong offset!");

// Function Phoenix.PhxProgressManager.SetNewGamePlus
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_SetNewGamePlus final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsNGPlus;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_SetNewGamePlus) == 0x000008, "Wrong alignment on PhxProgressManager_SetNewGamePlus");
static_assert(sizeof(PhxProgressManager_SetNewGamePlus) == 0x000010, "Wrong size on PhxProgressManager_SetNewGamePlus");
static_assert(offsetof(PhxProgressManager_SetNewGamePlus, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_SetNewGamePlus::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_SetNewGamePlus, bIsNGPlus) == 0x000008, "Member 'PhxProgressManager_SetNewGamePlus::bIsNGPlus' has a wrong offset!");

// Function Phoenix.PhxProgressManager.SetStoryDLC
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_SetStoryDLC final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsStoryDLC;                                       // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_SetStoryDLC) == 0x000008, "Wrong alignment on PhxProgressManager_SetStoryDLC");
static_assert(sizeof(PhxProgressManager_SetStoryDLC) == 0x000010, "Wrong size on PhxProgressManager_SetStoryDLC");
static_assert(offsetof(PhxProgressManager_SetStoryDLC, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_SetStoryDLC::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_SetStoryDLC, bIsStoryDLC) == 0x000008, "Member 'PhxProgressManager_SetStoryDLC::bIsStoryDLC' has a wrong offset!");

// Function Phoenix.PhxProgressManager.ShowCurrentObjectiveUINotification
// 0x0008 (0x0008 - 0x0000)
struct PhxProgressManager_ShowCurrentObjectiveUINotification final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_ShowCurrentObjectiveUINotification) == 0x000008, "Wrong alignment on PhxProgressManager_ShowCurrentObjectiveUINotification");
static_assert(sizeof(PhxProgressManager_ShowCurrentObjectiveUINotification) == 0x000008, "Wrong size on PhxProgressManager_ShowCurrentObjectiveUINotification");
static_assert(offsetof(PhxProgressManager_ShowCurrentObjectiveUINotification, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_ShowCurrentObjectiveUINotification::WorldContextObject' has a wrong offset!");

// Function Phoenix.PhxProgressManager.ShowSubObjective
// 0x0018 (0x0018 - 0x0000)
struct PhxProgressManager_ShowSubObjective final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           SubObjectiveTag;                                   // 0x0008(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimeRemaining;                                     // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_ShowSubObjective) == 0x000008, "Wrong alignment on PhxProgressManager_ShowSubObjective");
static_assert(sizeof(PhxProgressManager_ShowSubObjective) == 0x000018, "Wrong size on PhxProgressManager_ShowSubObjective");
static_assert(offsetof(PhxProgressManager_ShowSubObjective, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_ShowSubObjective::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_ShowSubObjective, SubObjectiveTag) == 0x000008, "Member 'PhxProgressManager_ShowSubObjective::SubObjectiveTag' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_ShowSubObjective, TimeRemaining) == 0x000010, "Member 'PhxProgressManager_ShowSubObjective::TimeRemaining' has a wrong offset!");

// Function Phoenix.PhxProgressManager.UpdateCurrentObjective
// 0x0018 (0x0018 - 0x0000)
struct PhxProgressManager_UpdateCurrentObjective final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           NewObjectiveTag;                                   // 0x0008(0x0008)(ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowUINotification;                               // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_UpdateCurrentObjective) == 0x000008, "Wrong alignment on PhxProgressManager_UpdateCurrentObjective");
static_assert(sizeof(PhxProgressManager_UpdateCurrentObjective) == 0x000018, "Wrong size on PhxProgressManager_UpdateCurrentObjective");
static_assert(offsetof(PhxProgressManager_UpdateCurrentObjective, WorldContextObject) == 0x000000, "Member 'PhxProgressManager_UpdateCurrentObjective::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_UpdateCurrentObjective, NewObjectiveTag) == 0x000008, "Member 'PhxProgressManager_UpdateCurrentObjective::NewObjectiveTag' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_UpdateCurrentObjective, bShowUINotification) == 0x000010, "Member 'PhxProgressManager_UpdateCurrentObjective::bShowUINotification' has a wrong offset!");

// Function Phoenix.PhxProgressManager.GivePlayerPendingItemsWithTag
// 0x0008 (0x0008 - 0x0000)
struct PhxProgressManager_GivePlayerPendingItemsWithTag final
{
public:
	struct FGameplayTag                           Tag;                                               // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProgressManager_GivePlayerPendingItemsWithTag) == 0x000004, "Wrong alignment on PhxProgressManager_GivePlayerPendingItemsWithTag");
static_assert(sizeof(PhxProgressManager_GivePlayerPendingItemsWithTag) == 0x000008, "Wrong size on PhxProgressManager_GivePlayerPendingItemsWithTag");
static_assert(offsetof(PhxProgressManager_GivePlayerPendingItemsWithTag, Tag) == 0x000000, "Member 'PhxProgressManager_GivePlayerPendingItemsWithTag::Tag' has a wrong offset!");

// Function Phoenix.PhxProgressManager.TryRecordPlayerState
// 0x0010 (0x0010 - 0x0000)
struct PhxProgressManager_TryRecordPlayerState final
{
public:
	class APhxCharacter*                          PlayerCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRecorded;                                         // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_TryRecordPlayerState) == 0x000008, "Wrong alignment on PhxProgressManager_TryRecordPlayerState");
static_assert(sizeof(PhxProgressManager_TryRecordPlayerState) == 0x000010, "Wrong size on PhxProgressManager_TryRecordPlayerState");
static_assert(offsetof(PhxProgressManager_TryRecordPlayerState, PlayerCharacter) == 0x000000, "Member 'PhxProgressManager_TryRecordPlayerState::PlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_TryRecordPlayerState, bRecorded) == 0x000008, "Member 'PhxProgressManager_TryRecordPlayerState::bRecorded' has a wrong offset!");

// Function Phoenix.PhxProgressManager.HasPendingItemsWithTag
// 0x000C (0x000C - 0x0000)
struct PhxProgressManager_HasPendingItemsWithTag final
{
public:
	struct FGameplayTag                           Tag;                                               // 0x0000(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProgressManager_HasPendingItemsWithTag) == 0x000004, "Wrong alignment on PhxProgressManager_HasPendingItemsWithTag");
static_assert(sizeof(PhxProgressManager_HasPendingItemsWithTag) == 0x00000C, "Wrong size on PhxProgressManager_HasPendingItemsWithTag");
static_assert(offsetof(PhxProgressManager_HasPendingItemsWithTag, Tag) == 0x000000, "Member 'PhxProgressManager_HasPendingItemsWithTag::Tag' has a wrong offset!");
static_assert(offsetof(PhxProgressManager_HasPendingItemsWithTag, ReturnValue) == 0x000008, "Member 'PhxProgressManager_HasPendingItemsWithTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxProximityGlassBreakComponent.OnBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxProximityGlassBreakComponent_OnBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProximityGlassBreakComponent_OnBeginOverlap) == 0x000008, "Wrong alignment on PhxProximityGlassBreakComponent_OnBeginOverlap");
static_assert(sizeof(PhxProximityGlassBreakComponent_OnBeginOverlap) == 0x0000A8, "Wrong size on PhxProximityGlassBreakComponent_OnBeginOverlap");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnBeginOverlap, OverlappedComponent) == 0x000000, "Member 'PhxProximityGlassBreakComponent_OnBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnBeginOverlap, OtherActor) == 0x000008, "Member 'PhxProximityGlassBreakComponent_OnBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnBeginOverlap, OtherComp) == 0x000010, "Member 'PhxProximityGlassBreakComponent_OnBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxProximityGlassBreakComponent_OnBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnBeginOverlap, bFromSweep) == 0x00001C, "Member 'PhxProximityGlassBreakComponent_OnBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnBeginOverlap, SweepResult) == 0x000020, "Member 'PhxProximityGlassBreakComponent_OnBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxProximityGlassBreakComponent.OnEndOverlap
// 0x0020 (0x0020 - 0x0000)
struct PhxProximityGlassBreakComponent_OnEndOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxProximityGlassBreakComponent_OnEndOverlap) == 0x000008, "Wrong alignment on PhxProximityGlassBreakComponent_OnEndOverlap");
static_assert(sizeof(PhxProximityGlassBreakComponent_OnEndOverlap) == 0x000020, "Wrong size on PhxProximityGlassBreakComponent_OnEndOverlap");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnEndOverlap, OverlappedComponent) == 0x000000, "Member 'PhxProximityGlassBreakComponent_OnEndOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnEndOverlap, OtherActor) == 0x000008, "Member 'PhxProximityGlassBreakComponent_OnEndOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnEndOverlap, OtherComp) == 0x000010, "Member 'PhxProximityGlassBreakComponent_OnEndOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxProximityGlassBreakComponent_OnEndOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxProximityGlassBreakComponent_OnEndOverlap::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PhxProximityLightComponent.TurnOff
// 0x0004 (0x0004 - 0x0000)
struct PhxProximityLightComponent_TurnOff final
{
public:
	float                                         Delay;                                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProximityLightComponent_TurnOff) == 0x000004, "Wrong alignment on PhxProximityLightComponent_TurnOff");
static_assert(sizeof(PhxProximityLightComponent_TurnOff) == 0x000004, "Wrong size on PhxProximityLightComponent_TurnOff");
static_assert(offsetof(PhxProximityLightComponent_TurnOff, Delay) == 0x000000, "Member 'PhxProximityLightComponent_TurnOff::Delay' has a wrong offset!");

// Function Phoenix.PhxProximityLightComponent.TurnOn
// 0x0004 (0x0004 - 0x0000)
struct PhxProximityLightComponent_TurnOn final
{
public:
	float                                         Delay;                                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxProximityLightComponent_TurnOn) == 0x000004, "Wrong alignment on PhxProximityLightComponent_TurnOn");
static_assert(sizeof(PhxProximityLightComponent_TurnOn) == 0x000004, "Wrong size on PhxProximityLightComponent_TurnOn");
static_assert(offsetof(PhxProximityLightComponent_TurnOn, Delay) == 0x000000, "Member 'PhxProximityLightComponent_TurnOn::Delay' has a wrong offset!");

// Function Phoenix.PhxQteSystem.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxQteSystem_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxQteSystem*                          ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_Get) == 0x000008, "Wrong alignment on PhxQteSystem_Get");
static_assert(sizeof(PhxQteSystem_Get) == 0x000010, "Wrong size on PhxQteSystem_Get");
static_assert(offsetof(PhxQteSystem_Get, WorldContextObject) == 0x000000, "Member 'PhxQteSystem_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxQteSystem_Get, ReturnValue) == 0x000008, "Member 'PhxQteSystem_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxQteSystem.DismissCurrentQte
// 0x0001 (0x0001 - 0x0000)
struct PhxQteSystem_DismissCurrentQte final
{
public:
	EPhxQteDismissType                            DismissType;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_DismissCurrentQte) == 0x000001, "Wrong alignment on PhxQteSystem_DismissCurrentQte");
static_assert(sizeof(PhxQteSystem_DismissCurrentQte) == 0x000001, "Wrong size on PhxQteSystem_DismissCurrentQte");
static_assert(offsetof(PhxQteSystem_DismissCurrentQte, DismissType) == 0x000000, "Member 'PhxQteSystem_DismissCurrentQte::DismissType' has a wrong offset!");

// Function Phoenix.PhxQteSystem.GetQteProgress
// 0x0004 (0x0004 - 0x0000)
struct PhxQteSystem_GetQteProgress final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_GetQteProgress) == 0x000004, "Wrong alignment on PhxQteSystem_GetQteProgress");
static_assert(sizeof(PhxQteSystem_GetQteProgress) == 0x000004, "Wrong size on PhxQteSystem_GetQteProgress");
static_assert(offsetof(PhxQteSystem_GetQteProgress, ReturnValue) == 0x000000, "Member 'PhxQteSystem_GetQteProgress::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxQteSystem.GetQteSubStateClass
// 0x0008 (0x0008 - 0x0000)
struct PhxQteSystem_GetQteSubStateClass final
{
public:
	TSubclassOf<class UState>                     ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_GetQteSubStateClass) == 0x000008, "Wrong alignment on PhxQteSystem_GetQteSubStateClass");
static_assert(sizeof(PhxQteSystem_GetQteSubStateClass) == 0x000008, "Wrong size on PhxQteSystem_GetQteSubStateClass");
static_assert(offsetof(PhxQteSystem_GetQteSubStateClass, ReturnValue) == 0x000000, "Member 'PhxQteSystem_GetQteSubStateClass::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxQteSystem.GetQteSubStateParams
// 0x0008 (0x0008 - 0x0000)
struct PhxQteSystem_GetQteSubStateParams final
{
public:
	class UQteStateParams*                        ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_GetQteSubStateParams) == 0x000008, "Wrong alignment on PhxQteSystem_GetQteSubStateParams");
static_assert(sizeof(PhxQteSystem_GetQteSubStateParams) == 0x000008, "Wrong size on PhxQteSystem_GetQteSubStateParams");
static_assert(offsetof(PhxQteSystem_GetQteSubStateParams, ReturnValue) == 0x000000, "Member 'PhxQteSystem_GetQteSubStateParams::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxQteSystem.OnButtonPromptSizeChanged
// 0x0001 (0x0001 - 0x0000)
struct PhxQteSystem_OnButtonPromptSizeChanged final
{
public:
	ESDSSize                                      NewSize;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_OnButtonPromptSizeChanged) == 0x000001, "Wrong alignment on PhxQteSystem_OnButtonPromptSizeChanged");
static_assert(sizeof(PhxQteSystem_OnButtonPromptSizeChanged) == 0x000001, "Wrong size on PhxQteSystem_OnButtonPromptSizeChanged");
static_assert(offsetof(PhxQteSystem_OnButtonPromptSizeChanged, NewSize) == 0x000000, "Member 'PhxQteSystem_OnButtonPromptSizeChanged::NewSize' has a wrong offset!");

// Function Phoenix.PhxQteSystem.QteBodyStateRequested
// 0x0001 (0x0001 - 0x0000)
struct PhxQteSystem_QteBodyStateRequested final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_QteBodyStateRequested) == 0x000001, "Wrong alignment on PhxQteSystem_QteBodyStateRequested");
static_assert(sizeof(PhxQteSystem_QteBodyStateRequested) == 0x000001, "Wrong size on PhxQteSystem_QteBodyStateRequested");
static_assert(offsetof(PhxQteSystem_QteBodyStateRequested, ReturnValue) == 0x000000, "Member 'PhxQteSystem_QteBodyStateRequested::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxQteSystem.RequestQte
// 0x0150 (0x0150 - 0x0000)
struct PhxQteSystem_RequestQte final
{
public:
	struct FQteRequest                            QteRequest;                                        // 0x0000(0x0150)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_RequestQte) == 0x000008, "Wrong alignment on PhxQteSystem_RequestQte");
static_assert(sizeof(PhxQteSystem_RequestQte) == 0x000150, "Wrong size on PhxQteSystem_RequestQte");
static_assert(offsetof(PhxQteSystem_RequestQte, QteRequest) == 0x000000, "Member 'PhxQteSystem_RequestQte::QteRequest' has a wrong offset!");

// Function Phoenix.PhxQteSystem.GetInputActionForActiveQte
// 0x0001 (0x0001 - 0x0000)
struct PhxQteSystem_GetInputActionForActiveQte final
{
public:
	EQteInputAction                               ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_GetInputActionForActiveQte) == 0x000001, "Wrong alignment on PhxQteSystem_GetInputActionForActiveQte");
static_assert(sizeof(PhxQteSystem_GetInputActionForActiveQte) == 0x000001, "Wrong size on PhxQteSystem_GetInputActionForActiveQte");
static_assert(offsetof(PhxQteSystem_GetInputActionForActiveQte, ReturnValue) == 0x000000, "Member 'PhxQteSystem_GetInputActionForActiveQte::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxQteSystem.IsActive
// 0x0001 (0x0001 - 0x0000)
struct PhxQteSystem_IsActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_IsActive) == 0x000001, "Wrong alignment on PhxQteSystem_IsActive");
static_assert(sizeof(PhxQteSystem_IsActive) == 0x000001, "Wrong size on PhxQteSystem_IsActive");
static_assert(offsetof(PhxQteSystem_IsActive, ReturnValue) == 0x000000, "Member 'PhxQteSystem_IsActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxQteSystem.IsAutoQteEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxQteSystem_IsAutoQteEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_IsAutoQteEnabled) == 0x000001, "Wrong alignment on PhxQteSystem_IsAutoQteEnabled");
static_assert(sizeof(PhxQteSystem_IsAutoQteEnabled) == 0x000001, "Wrong size on PhxQteSystem_IsAutoQteEnabled");
static_assert(offsetof(PhxQteSystem_IsAutoQteEnabled, ReturnValue) == 0x000000, "Member 'PhxQteSystem_IsAutoQteEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxQteSystem.IsRequestActive
// 0x0158 (0x0158 - 0x0000)
struct PhxQteSystem_IsRequestActive final
{
public:
	struct FQteRequest                            QteRequest;                                        // 0x0000(0x0150)(Parm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0150(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_151[0x7];                                      // 0x0151(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxQteSystem_IsRequestActive) == 0x000008, "Wrong alignment on PhxQteSystem_IsRequestActive");
static_assert(sizeof(PhxQteSystem_IsRequestActive) == 0x000158, "Wrong size on PhxQteSystem_IsRequestActive");
static_assert(offsetof(PhxQteSystem_IsRequestActive, QteRequest) == 0x000000, "Member 'PhxQteSystem_IsRequestActive::QteRequest' has a wrong offset!");
static_assert(offsetof(PhxQteSystem_IsRequestActive, ReturnValue) == 0x000150, "Member 'PhxQteSystem_IsRequestActive::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxQteSystem.IsUsingControllerActionForQte
// 0x0001 (0x0001 - 0x0000)
struct PhxQteSystem_IsUsingControllerActionForQte final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxQteSystem_IsUsingControllerActionForQte) == 0x000001, "Wrong alignment on PhxQteSystem_IsUsingControllerActionForQte");
static_assert(sizeof(PhxQteSystem_IsUsingControllerActionForQte) == 0x000001, "Wrong size on PhxQteSystem_IsUsingControllerActionForQte");
static_assert(offsetof(PhxQteSystem_IsUsingControllerActionForQte, ReturnValue) == 0x000000, "Member 'PhxQteSystem_IsUsingControllerActionForQte::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootProp_Weapon.ApplyDiscount
// 0x0008 (0x0008 - 0x0000)
struct PhxRiotModeLootProp_Weapon_ApplyDiscount final
{
public:
	EItemDataSubCategory                          ItemCategoryToDiscount;                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DiscountPercentage;                                // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootProp_Weapon_ApplyDiscount) == 0x000004, "Wrong alignment on PhxRiotModeLootProp_Weapon_ApplyDiscount");
static_assert(sizeof(PhxRiotModeLootProp_Weapon_ApplyDiscount) == 0x000008, "Wrong size on PhxRiotModeLootProp_Weapon_ApplyDiscount");
static_assert(offsetof(PhxRiotModeLootProp_Weapon_ApplyDiscount, ItemCategoryToDiscount) == 0x000000, "Member 'PhxRiotModeLootProp_Weapon_ApplyDiscount::ItemCategoryToDiscount' has a wrong offset!");
static_assert(offsetof(PhxRiotModeLootProp_Weapon_ApplyDiscount, DiscountPercentage) == 0x000004, "Member 'PhxRiotModeLootProp_Weapon_ApplyDiscount::DiscountPercentage' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootProp_Weapon.SetItemTier
// 0x0004 (0x0004 - 0x0000)
struct PhxRiotModeLootProp_Weapon_SetItemTier final
{
public:
	int32                                         Tier;                                              // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootProp_Weapon_SetItemTier) == 0x000004, "Wrong alignment on PhxRiotModeLootProp_Weapon_SetItemTier");
static_assert(sizeof(PhxRiotModeLootProp_Weapon_SetItemTier) == 0x000004, "Wrong size on PhxRiotModeLootProp_Weapon_SetItemTier");
static_assert(offsetof(PhxRiotModeLootProp_Weapon_SetItemTier, Tier) == 0x000000, "Member 'PhxRiotModeLootProp_Weapon_SetItemTier::Tier' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootProp_Weapon.GetAllPurchasesDone
// 0x0001 (0x0001 - 0x0000)
struct PhxRiotModeLootProp_Weapon_GetAllPurchasesDone final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootProp_Weapon_GetAllPurchasesDone) == 0x000001, "Wrong alignment on PhxRiotModeLootProp_Weapon_GetAllPurchasesDone");
static_assert(sizeof(PhxRiotModeLootProp_Weapon_GetAllPurchasesDone) == 0x000001, "Wrong size on PhxRiotModeLootProp_Weapon_GetAllPurchasesDone");
static_assert(offsetof(PhxRiotModeLootProp_Weapon_GetAllPurchasesDone, ReturnValue) == 0x000000, "Member 'PhxRiotModeLootProp_Weapon_GetAllPurchasesDone::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootProp_Weapon.GetItemClass
// 0x0008 (0x0008 - 0x0000)
struct PhxRiotModeLootProp_Weapon_GetItemClass final
{
public:
	TSubclassOf<class AEquippable>                ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootProp_Weapon_GetItemClass) == 0x000008, "Wrong alignment on PhxRiotModeLootProp_Weapon_GetItemClass");
static_assert(sizeof(PhxRiotModeLootProp_Weapon_GetItemClass) == 0x000008, "Wrong size on PhxRiotModeLootProp_Weapon_GetItemClass");
static_assert(offsetof(PhxRiotModeLootProp_Weapon_GetItemClass, ReturnValue) == 0x000000, "Member 'PhxRiotModeLootProp_Weapon_GetItemClass::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootProp_Weapon.GetItemCost
// 0x0004 (0x0004 - 0x0000)
struct PhxRiotModeLootProp_Weapon_GetItemCost final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootProp_Weapon_GetItemCost) == 0x000004, "Wrong alignment on PhxRiotModeLootProp_Weapon_GetItemCost");
static_assert(sizeof(PhxRiotModeLootProp_Weapon_GetItemCost) == 0x000004, "Wrong size on PhxRiotModeLootProp_Weapon_GetItemCost");
static_assert(offsetof(PhxRiotModeLootProp_Weapon_GetItemCost, ReturnValue) == 0x000000, "Member 'PhxRiotModeLootProp_Weapon_GetItemCost::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootProp_Weapon.GetItemTier
// 0x0004 (0x0004 - 0x0000)
struct PhxRiotModeLootProp_Weapon_GetItemTier final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootProp_Weapon_GetItemTier) == 0x000004, "Wrong alignment on PhxRiotModeLootProp_Weapon_GetItemTier");
static_assert(sizeof(PhxRiotModeLootProp_Weapon_GetItemTier) == 0x000004, "Wrong size on PhxRiotModeLootProp_Weapon_GetItemTier");
static_assert(offsetof(PhxRiotModeLootProp_Weapon_GetItemTier, ReturnValue) == 0x000000, "Member 'PhxRiotModeLootProp_Weapon_GetItemTier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootProp_Weapon.GetMaxItemTier
// 0x0004 (0x0004 - 0x0000)
struct PhxRiotModeLootProp_Weapon_GetMaxItemTier final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootProp_Weapon_GetMaxItemTier) == 0x000004, "Wrong alignment on PhxRiotModeLootProp_Weapon_GetMaxItemTier");
static_assert(sizeof(PhxRiotModeLootProp_Weapon_GetMaxItemTier) == 0x000004, "Wrong size on PhxRiotModeLootProp_Weapon_GetMaxItemTier");
static_assert(offsetof(PhxRiotModeLootProp_Weapon_GetMaxItemTier, ReturnValue) == 0x000000, "Member 'PhxRiotModeLootProp_Weapon_GetMaxItemTier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRiotModeLootPropManager.OnNewWeaponPurchasedFromCrate
// 0x0010 (0x0010 - 0x0000)
struct PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate final
{
public:
	TSubclassOf<class AEquippable>                OldWeapon;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class AEquippable>                NewWeapon;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate) == 0x000008, "Wrong alignment on PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate");
static_assert(sizeof(PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate) == 0x000010, "Wrong size on PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate");
static_assert(offsetof(PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate, OldWeapon) == 0x000000, "Member 'PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate::OldWeapon' has a wrong offset!");
static_assert(offsetof(PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate, NewWeapon) == 0x000008, "Member 'PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate::NewWeapon' has a wrong offset!");

// Function Phoenix.SDSSimpleNotification.CloseNotification
// 0x0008 (0x0008 - 0x0000)
struct SDSSimpleNotification_CloseNotification final
{
public:
	bool                                          bDelayClose;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ElapsedTime;                                       // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSSimpleNotification_CloseNotification) == 0x000004, "Wrong alignment on SDSSimpleNotification_CloseNotification");
static_assert(sizeof(SDSSimpleNotification_CloseNotification) == 0x000008, "Wrong size on SDSSimpleNotification_CloseNotification");
static_assert(offsetof(SDSSimpleNotification_CloseNotification, bDelayClose) == 0x000000, "Member 'SDSSimpleNotification_CloseNotification::bDelayClose' has a wrong offset!");
static_assert(offsetof(SDSSimpleNotification_CloseNotification, ElapsedTime) == 0x000004, "Member 'SDSSimpleNotification_CloseNotification::ElapsedTime' has a wrong offset!");

// Function Phoenix.SDSSimpleNotification.SetMessage
// 0x0018 (0x0018 - 0x0000)
struct SDSSimpleNotification_SetMessage final
{
public:
	class FText                                   InMessage;                                         // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSSimpleNotification_SetMessage) == 0x000008, "Wrong alignment on SDSSimpleNotification_SetMessage");
static_assert(sizeof(SDSSimpleNotification_SetMessage) == 0x000018, "Wrong size on SDSSimpleNotification_SetMessage");
static_assert(offsetof(SDSSimpleNotification_SetMessage, InMessage) == 0x000000, "Member 'SDSSimpleNotification_SetMessage::InMessage' has a wrong offset!");

// Function Phoenix.SDSSimpleNotification.SetNotificationData
// 0x0128 (0x0128 - 0x0000)
struct SDSSimpleNotification_SetNotificationData final
{
public:
	struct FNotificationData                      InData;                                            // 0x0000(0x0128)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSSimpleNotification_SetNotificationData) == 0x000008, "Wrong alignment on SDSSimpleNotification_SetNotificationData");
static_assert(sizeof(SDSSimpleNotification_SetNotificationData) == 0x000128, "Wrong size on SDSSimpleNotification_SetNotificationData");
static_assert(offsetof(SDSSimpleNotification_SetNotificationData, InData) == 0x000000, "Member 'SDSSimpleNotification_SetNotificationData::InData' has a wrong offset!");

// Function Phoenix.PPEProjectileGunWeapon.BP_OnPPEAccumulatedChargesChanged
// 0x0004 (0x0004 - 0x0000)
struct PPEProjectileGunWeapon_BP_OnPPEAccumulatedChargesChanged final
{
public:
	int32                                         NewNumCharges;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEProjectileGunWeapon_BP_OnPPEAccumulatedChargesChanged) == 0x000004, "Wrong alignment on PPEProjectileGunWeapon_BP_OnPPEAccumulatedChargesChanged");
static_assert(sizeof(PPEProjectileGunWeapon_BP_OnPPEAccumulatedChargesChanged) == 0x000004, "Wrong size on PPEProjectileGunWeapon_BP_OnPPEAccumulatedChargesChanged");
static_assert(offsetof(PPEProjectileGunWeapon_BP_OnPPEAccumulatedChargesChanged, NewNumCharges) == 0x000000, "Member 'PPEProjectileGunWeapon_BP_OnPPEAccumulatedChargesChanged::NewNumCharges' has a wrong offset!");

// Function Phoenix.PPEProjectileGunWeapon.BP_OnRechargingChargesChanged
// 0x0004 (0x0004 - 0x0000)
struct PPEProjectileGunWeapon_BP_OnRechargingChargesChanged final
{
public:
	int32                                         NewNumCharges;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEProjectileGunWeapon_BP_OnRechargingChargesChanged) == 0x000004, "Wrong alignment on PPEProjectileGunWeapon_BP_OnRechargingChargesChanged");
static_assert(sizeof(PPEProjectileGunWeapon_BP_OnRechargingChargesChanged) == 0x000004, "Wrong size on PPEProjectileGunWeapon_BP_OnRechargingChargesChanged");
static_assert(offsetof(PPEProjectileGunWeapon_BP_OnRechargingChargesChanged, NewNumCharges) == 0x000000, "Member 'PPEProjectileGunWeapon_BP_OnRechargingChargesChanged::NewNumCharges' has a wrong offset!");

// Function Phoenix.PPEProjectileGunWeapon.BP_UpdateNumChargesVisuals
// 0x0008 (0x0008 - 0x0000)
struct PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals final
{
public:
	int32                                         NumCharges;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AlphaHighestCharge;                                // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals) == 0x000004, "Wrong alignment on PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals");
static_assert(sizeof(PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals) == 0x000008, "Wrong size on PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals");
static_assert(offsetof(PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals, NumCharges) == 0x000000, "Member 'PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals::NumCharges' has a wrong offset!");
static_assert(offsetof(PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals, AlphaHighestCharge) == 0x000004, "Member 'PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals::AlphaHighestCharge' has a wrong offset!");

// Function Phoenix.PPEProjectileGunWeapon.LockProjectileTypes
// 0x0001 (0x0001 - 0x0000)
struct PPEProjectileGunWeapon_LockProjectileTypes final
{
public:
	uint8                                         TypesToLock;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEProjectileGunWeapon_LockProjectileTypes) == 0x000001, "Wrong alignment on PPEProjectileGunWeapon_LockProjectileTypes");
static_assert(sizeof(PPEProjectileGunWeapon_LockProjectileTypes) == 0x000001, "Wrong size on PPEProjectileGunWeapon_LockProjectileTypes");
static_assert(offsetof(PPEProjectileGunWeapon_LockProjectileTypes, TypesToLock) == 0x000000, "Member 'PPEProjectileGunWeapon_LockProjectileTypes::TypesToLock' has a wrong offset!");

// Function Phoenix.PPEProjectileGunWeapon.UnlockProjectileTypes
// 0x0001 (0x0001 - 0x0000)
struct PPEProjectileGunWeapon_UnlockProjectileTypes final
{
public:
	uint8                                         TypesToUnlock;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEProjectileGunWeapon_UnlockProjectileTypes) == 0x000001, "Wrong alignment on PPEProjectileGunWeapon_UnlockProjectileTypes");
static_assert(sizeof(PPEProjectileGunWeapon_UnlockProjectileTypes) == 0x000001, "Wrong size on PPEProjectileGunWeapon_UnlockProjectileTypes");
static_assert(offsetof(PPEProjectileGunWeapon_UnlockProjectileTypes, TypesToUnlock) == 0x000000, "Member 'PPEProjectileGunWeapon_UnlockProjectileTypes::TypesToUnlock' has a wrong offset!");

// Function Phoenix.PPEProjectileGunWeapon.UpdateHatchGlowEffects
// 0x0004 (0x0004 - 0x0000)
struct PPEProjectileGunWeapon_UpdateHatchGlowEffects final
{
public:
	int32                                         NewNumCharges;                                     // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEProjectileGunWeapon_UpdateHatchGlowEffects) == 0x000004, "Wrong alignment on PPEProjectileGunWeapon_UpdateHatchGlowEffects");
static_assert(sizeof(PPEProjectileGunWeapon_UpdateHatchGlowEffects) == 0x000004, "Wrong size on PPEProjectileGunWeapon_UpdateHatchGlowEffects");
static_assert(offsetof(PPEProjectileGunWeapon_UpdateHatchGlowEffects, NewNumCharges) == 0x000000, "Member 'PPEProjectileGunWeapon_UpdateHatchGlowEffects::NewNumCharges' has a wrong offset!");

// Function Phoenix.PPEProjectileGunWeapon.GetChargeComponent
// 0x0008 (0x0008 - 0x0000)
struct PPEProjectileGunWeapon_GetChargeComponent final
{
public:
	class UPPEChargeComponent*                    ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEProjectileGunWeapon_GetChargeComponent) == 0x000008, "Wrong alignment on PPEProjectileGunWeapon_GetChargeComponent");
static_assert(sizeof(PPEProjectileGunWeapon_GetChargeComponent) == 0x000008, "Wrong size on PPEProjectileGunWeapon_GetChargeComponent");
static_assert(offsetof(PPEProjectileGunWeapon_GetChargeComponent, ReturnValue) == 0x000000, "Member 'PPEProjectileGunWeapon_GetChargeComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PPEProjectileGunWeapon.GetUnlockedProjectileTypes
// 0x0004 (0x0004 - 0x0000)
struct PPEProjectileGunWeapon_GetUnlockedProjectileTypes final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEProjectileGunWeapon_GetUnlockedProjectileTypes) == 0x000004, "Wrong alignment on PPEProjectileGunWeapon_GetUnlockedProjectileTypes");
static_assert(sizeof(PPEProjectileGunWeapon_GetUnlockedProjectileTypes) == 0x000004, "Wrong size on PPEProjectileGunWeapon_GetUnlockedProjectileTypes");
static_assert(offsetof(PPEProjectileGunWeapon_GetUnlockedProjectileTypes, ReturnValue) == 0x000000, "Member 'PPEProjectileGunWeapon_GetUnlockedProjectileTypes::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxRiotObjectiveMessage.UpdateDuration
// 0x0004 (0x0004 - 0x0000)
struct PhxRiotObjectiveMessage_UpdateDuration final
{
public:
	float                                         InDuration;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxRiotObjectiveMessage_UpdateDuration) == 0x000004, "Wrong alignment on PhxRiotObjectiveMessage_UpdateDuration");
static_assert(sizeof(PhxRiotObjectiveMessage_UpdateDuration) == 0x000004, "Wrong size on PhxRiotObjectiveMessage_UpdateDuration");
static_assert(offsetof(PhxRiotObjectiveMessage_UpdateDuration, InDuration) == 0x000000, "Member 'PhxRiotObjectiveMessage_UpdateDuration::InDuration' has a wrong offset!");

// Function Phoenix.PhxTraversalActor.OnBackInteractionExecuted
// 0x0008 (0x0008 - 0x0000)
struct PhxTraversalActor_OnBackInteractionExecuted final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTraversalActor_OnBackInteractionExecuted) == 0x000008, "Wrong alignment on PhxTraversalActor_OnBackInteractionExecuted");
static_assert(sizeof(PhxTraversalActor_OnBackInteractionExecuted) == 0x000008, "Wrong size on PhxTraversalActor_OnBackInteractionExecuted");
static_assert(offsetof(PhxTraversalActor_OnBackInteractionExecuted, InteractedBy) == 0x000000, "Member 'PhxTraversalActor_OnBackInteractionExecuted::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxTraversalActor.OnFrontInteractionExecuted
// 0x0008 (0x0008 - 0x0000)
struct PhxTraversalActor_OnFrontInteractionExecuted final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTraversalActor_OnFrontInteractionExecuted) == 0x000008, "Wrong alignment on PhxTraversalActor_OnFrontInteractionExecuted");
static_assert(sizeof(PhxTraversalActor_OnFrontInteractionExecuted) == 0x000008, "Wrong size on PhxTraversalActor_OnFrontInteractionExecuted");
static_assert(offsetof(PhxTraversalActor_OnFrontInteractionExecuted, InteractedBy) == 0x000000, "Member 'PhxTraversalActor_OnFrontInteractionExecuted::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxTraversalActor.ToggleInteraction
// 0x0001 (0x0001 - 0x0000)
struct PhxTraversalActor_ToggleInteraction final
{
public:
	bool                                          bEnableInteraction;                                // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTraversalActor_ToggleInteraction) == 0x000001, "Wrong alignment on PhxTraversalActor_ToggleInteraction");
static_assert(sizeof(PhxTraversalActor_ToggleInteraction) == 0x000001, "Wrong size on PhxTraversalActor_ToggleInteraction");
static_assert(offsetof(PhxTraversalActor_ToggleInteraction, bEnableInteraction) == 0x000000, "Member 'PhxTraversalActor_ToggleInteraction::bEnableInteraction' has a wrong offset!");

// Function Phoenix.PhxScriptedEventBlueprintLibrary.QueueUpScriptedEventActionRequest
// 0x0018 (0x0018 - 0x0000)
struct PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest final
{
public:
	class APhxCharacterBase*                      CharacterOwner;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UPhxScrEvtCharacterActionRequest> ActionRequestClass;                          // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxScrEvtCharacterActionRequest*       ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest) == 0x000008, "Wrong alignment on PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest");
static_assert(sizeof(PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest) == 0x000018, "Wrong size on PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest");
static_assert(offsetof(PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest, CharacterOwner) == 0x000000, "Member 'PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest::CharacterOwner' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest, ActionRequestClass) == 0x000008, "Member 'PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest::ActionRequestClass' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest, ReturnValue) == 0x000010, "Member 'PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxScriptedEventCharacterState.OnAnimMontageStarted
// 0x0008 (0x0008 - 0x0000)
struct PhxScriptedEventCharacterState_OnAnimMontageStarted final
{
public:
	class UAnimMontage*                           AnimMontage;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventCharacterState_OnAnimMontageStarted) == 0x000008, "Wrong alignment on PhxScriptedEventCharacterState_OnAnimMontageStarted");
static_assert(sizeof(PhxScriptedEventCharacterState_OnAnimMontageStarted) == 0x000008, "Wrong size on PhxScriptedEventCharacterState_OnAnimMontageStarted");
static_assert(offsetof(PhxScriptedEventCharacterState_OnAnimMontageStarted, AnimMontage) == 0x000000, "Member 'PhxScriptedEventCharacterState_OnAnimMontageStarted::AnimMontage' has a wrong offset!");

// Function Phoenix.PhxScriptedEventCharacterState.OnCancelQTE
// 0x0008 (0x0008 - 0x0000)
struct PhxScriptedEventCharacterState_OnCancelQTE final
{
public:
	class FName                                   InQteId;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxScriptedEventCharacterState_OnCancelQTE) == 0x000004, "Wrong alignment on PhxScriptedEventCharacterState_OnCancelQTE");
static_assert(sizeof(PhxScriptedEventCharacterState_OnCancelQTE) == 0x000008, "Wrong size on PhxScriptedEventCharacterState_OnCancelQTE");
static_assert(offsetof(PhxScriptedEventCharacterState_OnCancelQTE, InQteId) == 0x000000, "Member 'PhxScriptedEventCharacterState_OnCancelQTE::InQteId' has a wrong offset!");

// Function Phoenix.PhxScriptedEventCharacterState.OnCompleteQTE
// 0x000C (0x000C - 0x0000)
struct PhxScriptedEventCharacterState_OnCompleteQTE final
{
public:
	class FName                                   InQteId;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInResult;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxScriptedEventCharacterState_OnCompleteQTE) == 0x000004, "Wrong alignment on PhxScriptedEventCharacterState_OnCompleteQTE");
static_assert(sizeof(PhxScriptedEventCharacterState_OnCompleteQTE) == 0x00000C, "Wrong size on PhxScriptedEventCharacterState_OnCompleteQTE");
static_assert(offsetof(PhxScriptedEventCharacterState_OnCompleteQTE, InQteId) == 0x000000, "Member 'PhxScriptedEventCharacterState_OnCompleteQTE::InQteId' has a wrong offset!");
static_assert(offsetof(PhxScriptedEventCharacterState_OnCompleteQTE, bInResult) == 0x000008, "Member 'PhxScriptedEventCharacterState_OnCompleteQTE::bInResult' has a wrong offset!");

// Function Phoenix.PhxTraversalSpline.RegisterAnimationPoint
// 0x0010 (0x0010 - 0x0000)
struct PhxTraversalSpline_RegisterAnimationPoint final
{
public:
	class APhxTraversalSplinePoint_Animation*     AnimationPoint;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShouldDeformSpline;                               // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0009(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxTraversalSpline_RegisterAnimationPoint) == 0x000008, "Wrong alignment on PhxTraversalSpline_RegisterAnimationPoint");
static_assert(sizeof(PhxTraversalSpline_RegisterAnimationPoint) == 0x000010, "Wrong size on PhxTraversalSpline_RegisterAnimationPoint");
static_assert(offsetof(PhxTraversalSpline_RegisterAnimationPoint, AnimationPoint) == 0x000000, "Member 'PhxTraversalSpline_RegisterAnimationPoint::AnimationPoint' has a wrong offset!");
static_assert(offsetof(PhxTraversalSpline_RegisterAnimationPoint, bShouldDeformSpline) == 0x000008, "Member 'PhxTraversalSpline_RegisterAnimationPoint::bShouldDeformSpline' has a wrong offset!");
static_assert(offsetof(PhxTraversalSpline_RegisterAnimationPoint, ReturnValue) == 0x000009, "Member 'PhxTraversalSpline_RegisterAnimationPoint::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSearchLight.InitializeSearchLight
// 0x0020 (0x0020 - 0x0000)
struct PhxSearchLight_InitializeSearchLight final
{
public:
	class UArrowComponent*                        InArrowComp;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTimelineComponent*                     InSearchLightTimelineComp;                         // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTimelineComponent*                     InOverwriteLocationTargetTimelineComp;             // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTimelineComponent*                     InFollowTimelineComp;                              // 0x0018(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSearchLight_InitializeSearchLight) == 0x000008, "Wrong alignment on PhxSearchLight_InitializeSearchLight");
static_assert(sizeof(PhxSearchLight_InitializeSearchLight) == 0x000020, "Wrong size on PhxSearchLight_InitializeSearchLight");
static_assert(offsetof(PhxSearchLight_InitializeSearchLight, InArrowComp) == 0x000000, "Member 'PhxSearchLight_InitializeSearchLight::InArrowComp' has a wrong offset!");
static_assert(offsetof(PhxSearchLight_InitializeSearchLight, InSearchLightTimelineComp) == 0x000008, "Member 'PhxSearchLight_InitializeSearchLight::InSearchLightTimelineComp' has a wrong offset!");
static_assert(offsetof(PhxSearchLight_InitializeSearchLight, InOverwriteLocationTargetTimelineComp) == 0x000010, "Member 'PhxSearchLight_InitializeSearchLight::InOverwriteLocationTargetTimelineComp' has a wrong offset!");
static_assert(offsetof(PhxSearchLight_InitializeSearchLight, InFollowTimelineComp) == 0x000018, "Member 'PhxSearchLight_InitializeSearchLight::InFollowTimelineComp' has a wrong offset!");

// Function Phoenix.PhxSearchLight.SetSearchLightFollowActor
// 0x0008 (0x0008 - 0x0000)
struct PhxSearchLight_SetSearchLightFollowActor final
{
public:
	class AActor*                                 InActor;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSearchLight_SetSearchLightFollowActor) == 0x000008, "Wrong alignment on PhxSearchLight_SetSearchLightFollowActor");
static_assert(sizeof(PhxSearchLight_SetSearchLightFollowActor) == 0x000008, "Wrong size on PhxSearchLight_SetSearchLightFollowActor");
static_assert(offsetof(PhxSearchLight_SetSearchLightFollowActor, InActor) == 0x000000, "Member 'PhxSearchLight_SetSearchLightFollowActor::InActor' has a wrong offset!");

// Function Phoenix.PhxSearchLight.SetSearchLightOverwriteActor
// 0x0008 (0x0008 - 0x0000)
struct PhxSearchLight_SetSearchLightOverwriteActor final
{
public:
	class AActor*                                 InActor;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSearchLight_SetSearchLightOverwriteActor) == 0x000008, "Wrong alignment on PhxSearchLight_SetSearchLightOverwriteActor");
static_assert(sizeof(PhxSearchLight_SetSearchLightOverwriteActor) == 0x000008, "Wrong size on PhxSearchLight_SetSearchLightOverwriteActor");
static_assert(offsetof(PhxSearchLight_SetSearchLightOverwriteActor, InActor) == 0x000000, "Member 'PhxSearchLight_SetSearchLightOverwriteActor::InActor' has a wrong offset!");

// Function Phoenix.PhxSearchLight.SetSearchLightTargetActor
// 0x0008 (0x0008 - 0x0000)
struct PhxSearchLight_SetSearchLightTargetActor final
{
public:
	class AActor*                                 InActor;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSearchLight_SetSearchLightTargetActor) == 0x000008, "Wrong alignment on PhxSearchLight_SetSearchLightTargetActor");
static_assert(sizeof(PhxSearchLight_SetSearchLightTargetActor) == 0x000008, "Wrong size on PhxSearchLight_SetSearchLightTargetActor");
static_assert(offsetof(PhxSearchLight_SetSearchLightTargetActor, InActor) == 0x000000, "Member 'PhxSearchLight_SetSearchLightTargetActor::InActor' has a wrong offset!");

// Function Phoenix.PhxSearchLight.UpdateFollowTimelineFunc
// 0x0004 (0x0004 - 0x0000)
struct PhxSearchLight_UpdateFollowTimelineFunc final
{
public:
	float                                         OutputAlpha;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSearchLight_UpdateFollowTimelineFunc) == 0x000004, "Wrong alignment on PhxSearchLight_UpdateFollowTimelineFunc");
static_assert(sizeof(PhxSearchLight_UpdateFollowTimelineFunc) == 0x000004, "Wrong size on PhxSearchLight_UpdateFollowTimelineFunc");
static_assert(offsetof(PhxSearchLight_UpdateFollowTimelineFunc, OutputAlpha) == 0x000000, "Member 'PhxSearchLight_UpdateFollowTimelineFunc::OutputAlpha' has a wrong offset!");

// Function Phoenix.PhxSearchLight.UpdateOverwriteLocationTargetTimelineFunc
// 0x0004 (0x0004 - 0x0000)
struct PhxSearchLight_UpdateOverwriteLocationTargetTimelineFunc final
{
public:
	float                                         OutputAlpha;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSearchLight_UpdateOverwriteLocationTargetTimelineFunc) == 0x000004, "Wrong alignment on PhxSearchLight_UpdateOverwriteLocationTargetTimelineFunc");
static_assert(sizeof(PhxSearchLight_UpdateOverwriteLocationTargetTimelineFunc) == 0x000004, "Wrong size on PhxSearchLight_UpdateOverwriteLocationTargetTimelineFunc");
static_assert(offsetof(PhxSearchLight_UpdateOverwriteLocationTargetTimelineFunc, OutputAlpha) == 0x000000, "Member 'PhxSearchLight_UpdateOverwriteLocationTargetTimelineFunc::OutputAlpha' has a wrong offset!");

// Function Phoenix.PhxSearchLight.UpdateSearchLightTimelineFunc
// 0x0004 (0x0004 - 0x0000)
struct PhxSearchLight_UpdateSearchLightTimelineFunc final
{
public:
	float                                         OutputAlpha;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSearchLight_UpdateSearchLightTimelineFunc) == 0x000004, "Wrong alignment on PhxSearchLight_UpdateSearchLightTimelineFunc");
static_assert(sizeof(PhxSearchLight_UpdateSearchLightTimelineFunc) == 0x000004, "Wrong size on PhxSearchLight_UpdateSearchLightTimelineFunc");
static_assert(offsetof(PhxSearchLight_UpdateSearchLightTimelineFunc, OutputAlpha) == 0x000000, "Member 'PhxSearchLight_UpdateSearchLightTimelineFunc::OutputAlpha' has a wrong offset!");

// Function Phoenix.PhxSendPlayerDeathTelemetry.SendPlayerDeathTelemetry
// 0x0028 (0x0028 - 0x0000)
struct PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxPlayerCharacter*                    PlayerCharacter;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DamageAmount;                                      // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class AActor*                                 DamageCauser;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxSendPlayerDeathTelemetry*           ReturnValue;                                       // 0x0020(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry) == 0x000008, "Wrong alignment on PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry");
static_assert(sizeof(PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry) == 0x000028, "Wrong size on PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry");
static_assert(offsetof(PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry, WorldContextObject) == 0x000000, "Member 'PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry, PlayerCharacter) == 0x000008, "Member 'PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry::PlayerCharacter' has a wrong offset!");
static_assert(offsetof(PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry, DamageAmount) == 0x000010, "Member 'PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry::DamageAmount' has a wrong offset!");
static_assert(offsetof(PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry, DamageCauser) == 0x000018, "Member 'PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry::DamageCauser' has a wrong offset!");
static_assert(offsetof(PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry, ReturnValue) == 0x000020, "Member 'PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSimpleElevator.OnBottomFloorPanelInteract
// 0x0008 (0x0008 - 0x0000)
struct PhxSimpleElevator_OnBottomFloorPanelInteract final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSimpleElevator_OnBottomFloorPanelInteract) == 0x000008, "Wrong alignment on PhxSimpleElevator_OnBottomFloorPanelInteract");
static_assert(sizeof(PhxSimpleElevator_OnBottomFloorPanelInteract) == 0x000008, "Wrong size on PhxSimpleElevator_OnBottomFloorPanelInteract");
static_assert(offsetof(PhxSimpleElevator_OnBottomFloorPanelInteract, InteractedBy) == 0x000000, "Member 'PhxSimpleElevator_OnBottomFloorPanelInteract::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxSimpleElevator.OnElevatorStartInteract
// 0x0008 (0x0008 - 0x0000)
struct PhxSimpleElevator_OnElevatorStartInteract final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSimpleElevator_OnElevatorStartInteract) == 0x000008, "Wrong alignment on PhxSimpleElevator_OnElevatorStartInteract");
static_assert(sizeof(PhxSimpleElevator_OnElevatorStartInteract) == 0x000008, "Wrong size on PhxSimpleElevator_OnElevatorStartInteract");
static_assert(offsetof(PhxSimpleElevator_OnElevatorStartInteract, InteractedBy) == 0x000000, "Member 'PhxSimpleElevator_OnElevatorStartInteract::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxSimpleElevator.OnTopFloorPanelInteract
// 0x0008 (0x0008 - 0x0000)
struct PhxSimpleElevator_OnTopFloorPanelInteract final
{
public:
	class APhxCharacter*                          InteractedBy;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSimpleElevator_OnTopFloorPanelInteract) == 0x000008, "Wrong alignment on PhxSimpleElevator_OnTopFloorPanelInteract");
static_assert(sizeof(PhxSimpleElevator_OnTopFloorPanelInteract) == 0x000008, "Wrong size on PhxSimpleElevator_OnTopFloorPanelInteract");
static_assert(offsetof(PhxSimpleElevator_OnTopFloorPanelInteract, InteractedBy) == 0x000000, "Member 'PhxSimpleElevator_OnTopFloorPanelInteract::InteractedBy' has a wrong offset!");

// Function Phoenix.PhxSimpleElevator.GetElevatorSpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxSimpleElevator_GetElevatorSpeed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSimpleElevator_GetElevatorSpeed) == 0x000004, "Wrong alignment on PhxSimpleElevator_GetElevatorSpeed");
static_assert(sizeof(PhxSimpleElevator_GetElevatorSpeed) == 0x000004, "Wrong size on PhxSimpleElevator_GetElevatorSpeed");
static_assert(offsetof(PhxSimpleElevator_GetElevatorSpeed, ReturnValue) == 0x000000, "Member 'PhxSimpleElevator_GetElevatorSpeed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSimpleElevator.GetElevatorStartInteractable
// 0x0008 (0x0008 - 0x0000)
struct PhxSimpleElevator_GetElevatorStartInteractable final
{
public:
	class UInteractableComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSimpleElevator_GetElevatorStartInteractable) == 0x000008, "Wrong alignment on PhxSimpleElevator_GetElevatorStartInteractable");
static_assert(sizeof(PhxSimpleElevator_GetElevatorStartInteractable) == 0x000008, "Wrong size on PhxSimpleElevator_GetElevatorStartInteractable");
static_assert(offsetof(PhxSimpleElevator_GetElevatorStartInteractable, ReturnValue) == 0x000000, "Member 'PhxSimpleElevator_GetElevatorStartInteractable::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSkinnableCharacterInterface.GetSkinnableCharacterTag
// 0x0008 (0x0008 - 0x0000)
struct PhxSkinnableCharacterInterface_GetSkinnableCharacterTag final
{
public:
	struct FGameplayTag                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSkinnableCharacterInterface_GetSkinnableCharacterTag) == 0x000004, "Wrong alignment on PhxSkinnableCharacterInterface_GetSkinnableCharacterTag");
static_assert(sizeof(PhxSkinnableCharacterInterface_GetSkinnableCharacterTag) == 0x000008, "Wrong size on PhxSkinnableCharacterInterface_GetSkinnableCharacterTag");
static_assert(offsetof(PhxSkinnableCharacterInterface_GetSkinnableCharacterTag, ReturnValue) == 0x000000, "Member 'PhxSkinnableCharacterInterface_GetSkinnableCharacterTag::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSkinnableCharacterInterface.GetSkinnableMainMesh
// 0x0008 (0x0008 - 0x0000)
struct PhxSkinnableCharacterInterface_GetSkinnableMainMesh final
{
public:
	class USkeletalMeshComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSkinnableCharacterInterface_GetSkinnableMainMesh) == 0x000008, "Wrong alignment on PhxSkinnableCharacterInterface_GetSkinnableMainMesh");
static_assert(sizeof(PhxSkinnableCharacterInterface_GetSkinnableMainMesh) == 0x000008, "Wrong size on PhxSkinnableCharacterInterface_GetSkinnableMainMesh");
static_assert(offsetof(PhxSkinnableCharacterInterface_GetSkinnableMainMesh, ReturnValue) == 0x000000, "Member 'PhxSkinnableCharacterInterface_GetSkinnableMainMesh::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSkinnableCharacterInterface.IsSkinnablePlayer
// 0x0001 (0x0001 - 0x0000)
struct PhxSkinnableCharacterInterface_IsSkinnablePlayer final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSkinnableCharacterInterface_IsSkinnablePlayer) == 0x000001, "Wrong alignment on PhxSkinnableCharacterInterface_IsSkinnablePlayer");
static_assert(sizeof(PhxSkinnableCharacterInterface_IsSkinnablePlayer) == 0x000001, "Wrong size on PhxSkinnableCharacterInterface_IsSkinnablePlayer");
static_assert(offsetof(PhxSkinnableCharacterInterface_IsSkinnablePlayer, ReturnValue) == 0x000000, "Member 'PhxSkinnableCharacterInterface_IsSkinnablePlayer::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSnowcat.SetDriverDoorOpen
// 0x0001 (0x0001 - 0x0000)
struct PhxSnowcat_SetDriverDoorOpen final
{
public:
	bool                                          bDoorOpen;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSnowcat_SetDriverDoorOpen) == 0x000001, "Wrong alignment on PhxSnowcat_SetDriverDoorOpen");
static_assert(sizeof(PhxSnowcat_SetDriverDoorOpen) == 0x000001, "Wrong size on PhxSnowcat_SetDriverDoorOpen");
static_assert(offsetof(PhxSnowcat_SetDriverDoorOpen, bDoorOpen) == 0x000000, "Member 'PhxSnowcat_SetDriverDoorOpen::bDoorOpen' has a wrong offset!");

// Function Phoenix.PhxSnowcat.SetWindshieldWipersActive
// 0x0001 (0x0001 - 0x0000)
struct PhxSnowcat_SetWindshieldWipersActive final
{
public:
	bool                                          bActive;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSnowcat_SetWindshieldWipersActive) == 0x000001, "Wrong alignment on PhxSnowcat_SetWindshieldWipersActive");
static_assert(sizeof(PhxSnowcat_SetWindshieldWipersActive) == 0x000001, "Wrong size on PhxSnowcat_SetWindshieldWipersActive");
static_assert(offsetof(PhxSnowcat_SetWindshieldWipersActive, bActive) == 0x000000, "Member 'PhxSnowcat_SetWindshieldWipersActive::bActive' has a wrong offset!");

// Function Phoenix.PhxSnowcat.UpdateDashboardUISpeed
// 0x0004 (0x0004 - 0x0000)
struct PhxSnowcat_UpdateDashboardUISpeed final
{
public:
	float                                         CurrentSpeed;                                      // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSnowcat_UpdateDashboardUISpeed) == 0x000004, "Wrong alignment on PhxSnowcat_UpdateDashboardUISpeed");
static_assert(sizeof(PhxSnowcat_UpdateDashboardUISpeed) == 0x000004, "Wrong size on PhxSnowcat_UpdateDashboardUISpeed");
static_assert(offsetof(PhxSnowcat_UpdateDashboardUISpeed, CurrentSpeed) == 0x000000, "Member 'PhxSnowcat_UpdateDashboardUISpeed::CurrentSpeed' has a wrong offset!");

// Function Phoenix.PhxSnowcat.UpdateDashboardUITurnStrength
// 0x0004 (0x0004 - 0x0000)
struct PhxSnowcat_UpdateDashboardUITurnStrength final
{
public:
	float                                         TurnStrength;                                      // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSnowcat_UpdateDashboardUITurnStrength) == 0x000004, "Wrong alignment on PhxSnowcat_UpdateDashboardUITurnStrength");
static_assert(sizeof(PhxSnowcat_UpdateDashboardUITurnStrength) == 0x000004, "Wrong size on PhxSnowcat_UpdateDashboardUITurnStrength");
static_assert(offsetof(PhxSnowcat_UpdateDashboardUITurnStrength, TurnStrength) == 0x000000, "Member 'PhxSnowcat_UpdateDashboardUITurnStrength::TurnStrength' has a wrong offset!");

// Function Phoenix.PhxSnowcat.GetDriverAttachComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxSnowcat_GetDriverAttachComponent final
{
public:
	class USceneComponent*                        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSnowcat_GetDriverAttachComponent) == 0x000008, "Wrong alignment on PhxSnowcat_GetDriverAttachComponent");
static_assert(sizeof(PhxSnowcat_GetDriverAttachComponent) == 0x000008, "Wrong size on PhxSnowcat_GetDriverAttachComponent");
static_assert(offsetof(PhxSnowcat_GetDriverAttachComponent, ReturnValue) == 0x000000, "Member 'PhxSnowcat_GetDriverAttachComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSnowcat.GetPassengerAttachComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxSnowcat_GetPassengerAttachComponent final
{
public:
	class USceneComponent*                        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSnowcat_GetPassengerAttachComponent) == 0x000008, "Wrong alignment on PhxSnowcat_GetPassengerAttachComponent");
static_assert(sizeof(PhxSnowcat_GetPassengerAttachComponent) == 0x000008, "Wrong size on PhxSnowcat_GetPassengerAttachComponent");
static_assert(offsetof(PhxSnowcat_GetPassengerAttachComponent, ReturnValue) == 0x000000, "Member 'PhxSnowcat_GetPassengerAttachComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSPromptWidgetProgress.SetProgress
// 0x0004 (0x0004 - 0x0000)
struct SDSPromptWidgetProgress_SetProgress final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSPromptWidgetProgress_SetProgress) == 0x000004, "Wrong alignment on SDSPromptWidgetProgress_SetProgress");
static_assert(sizeof(SDSPromptWidgetProgress_SetProgress) == 0x000004, "Wrong size on SDSPromptWidgetProgress_SetProgress");
static_assert(offsetof(SDSPromptWidgetProgress_SetProgress, InValue) == 0x000000, "Member 'SDSPromptWidgetProgress_SetProgress::InValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.BodyfallGeneralSound
// 0x0040 (0x0040 - 0x0000)
struct PhxSoundAnimNotifyLibrary_BodyfallGeneralSound final
{
public:
	class USkeletalMeshComponent*                 MeshComponent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketBeginOffset;                                 // 0x0018(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketEndOffset;                                   // 0x0024(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x0030(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HalfHeight;                                        // 0x0034(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkComponent*                           ReturnValue;                                       // 0x0038(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_BodyfallGeneralSound) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_BodyfallGeneralSound");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_BodyfallGeneralSound) == 0x000040, "Wrong size on PhxSoundAnimNotifyLibrary_BodyfallGeneralSound");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallGeneralSound, MeshComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_BodyfallGeneralSound::MeshComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallGeneralSound, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_BodyfallGeneralSound::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallGeneralSound, SocketBeginOffset) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_BodyfallGeneralSound::SocketBeginOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallGeneralSound, SocketEndOffset) == 0x000024, "Member 'PhxSoundAnimNotifyLibrary_BodyfallGeneralSound::SocketEndOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallGeneralSound, Radius) == 0x000030, "Member 'PhxSoundAnimNotifyLibrary_BodyfallGeneralSound::Radius' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallGeneralSound, HalfHeight) == 0x000034, "Member 'PhxSoundAnimNotifyLibrary_BodyfallGeneralSound::HalfHeight' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallGeneralSound, ReturnValue) == 0x000038, "Member 'PhxSoundAnimNotifyLibrary_BodyfallGeneralSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.BodyfallMaterialCheck
// 0x00C8 (0x00C8 - 0x0000)
struct PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck final
{
public:
	class USceneComponent*                        MeshComponent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             OutHit;                                            // 0x0018(0x0088)(Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FVector                                SocketBeginOffset;                                 // 0x00A0(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketEndOffset;                                   // 0x00AC(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x00B8(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HalfHeight;                                        // 0x00BC(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00C0(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck) == 0x0000C8, "Wrong size on PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck, MeshComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck::MeshComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck, OutHit) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck::OutHit' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck, SocketBeginOffset) == 0x0000A0, "Member 'PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck::SocketBeginOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck, SocketEndOffset) == 0x0000AC, "Member 'PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck::SocketEndOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck, Radius) == 0x0000B8, "Member 'PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck::Radius' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck, HalfHeight) == 0x0000BC, "Member 'PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck::HalfHeight' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck, ReturnValue) == 0x0000C0, "Member 'PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.BodyfallSkelCheckSound
// 0x0048 (0x0048 - 0x0000)
struct PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound final
{
public:
	class USkeletalMeshComponent*                 MeshComponent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkComponent*                           AkComponent;                                       // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketBeginOffset;                                 // 0x0020(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketEndOffset;                                   // 0x002C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x0038(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HalfHeight;                                        // 0x003C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0040(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_41[0x7];                                       // 0x0041(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound) == 0x000048, "Wrong size on PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound, MeshComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound::MeshComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound, AkComponent) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound::AkComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound, SocketBeginOffset) == 0x000020, "Member 'PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound::SocketBeginOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound, SocketEndOffset) == 0x00002C, "Member 'PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound::SocketEndOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound, Radius) == 0x000038, "Member 'PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound::Radius' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound, HalfHeight) == 0x00003C, "Member 'PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound::HalfHeight' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound, ReturnValue) == 0x000040, "Member 'PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.DefaultBodyfallMaterial
// 0x0018 (0x0018 - 0x0000)
struct PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial) == 0x000018, "Wrong size on PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial, WorldContextObject) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial, ReturnValue) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.DefaultFootstepMaterialName
// 0x0018 (0x0018 - 0x0000)
struct PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName) == 0x000018, "Wrong size on PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName, WorldContextObject) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName, ReturnValue) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.DefaultGruntSkeleton
// 0x0018 (0x0018 - 0x0000)
struct PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton) == 0x000018, "Wrong size on PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton, WorldContextObject) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton, ReturnValue) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.DefaultPhysicalMaterial
// 0x0018 (0x0018 - 0x0000)
struct PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial) == 0x000018, "Wrong size on PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial, WorldContextObject) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial, ReturnValue) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.FootstepMaterialCheck
// 0x00C8 (0x00C8 - 0x0000)
struct PhxSoundAnimNotifyLibrary_FootstepMaterialCheck final
{
public:
	class USceneComponent*                        MeshComponent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             OutHit;                                            // 0x0018(0x0088)(Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FVector                                BeginOffset;                                       // 0x00A0(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                EndOffset;                                         // 0x00AC(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                HalfSize;                                          // 0x00B8(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00C4(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C5[0x3];                                       // 0x00C5(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheck) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_FootstepMaterialCheck");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheck) == 0x0000C8, "Wrong size on PhxSoundAnimNotifyLibrary_FootstepMaterialCheck");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheck, MeshComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheck::MeshComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheck, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheck::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheck, OutHit) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheck::OutHit' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheck, BeginOffset) == 0x0000A0, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheck::BeginOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheck, EndOffset) == 0x0000AC, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheck::EndOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheck, HalfSize) == 0x0000B8, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheck::HalfSize' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheck, ReturnValue) == 0x0000C4, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheck::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.FootstepMaterialCheckRusher
// 0x00C0 (0x00C0 - 0x0000)
struct PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher final
{
public:
	class USceneComponent*                        SceneComponent;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             OutHit;                                            // 0x0018(0x0088)(Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FVector                                SocketBeginOffset;                                 // 0x00A0(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketEndOffset;                                   // 0x00AC(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x00B8(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00BC(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BD[0x3];                                       // 0x00BD(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher) == 0x0000C0, "Wrong size on PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher, SceneComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher::SceneComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher, OutHit) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher::OutHit' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher, SocketBeginOffset) == 0x0000A0, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher::SocketBeginOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher, SocketEndOffset) == 0x0000AC, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher::SocketEndOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher, Radius) == 0x0000B8, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher::Radius' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher, ReturnValue) == 0x0000BC, "Member 'PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.FootstepSimple
// 0x0050 (0x0050 - 0x0000)
struct PhxSoundAnimNotifyLibrary_FootstepSimple final
{
public:
	class USkeletalMeshComponent*                 MeshComponent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkSwitchValue*                         SwitchValue;                                       // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketBeginOffset;                                 // 0x0020(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketEndOffset;                                   // 0x002C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketHalfSize;                                    // 0x0038(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UAkComponent*                           AkObject;                                          // 0x0048(0x0008)(Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_FootstepSimple) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_FootstepSimple");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_FootstepSimple) == 0x000050, "Wrong size on PhxSoundAnimNotifyLibrary_FootstepSimple");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimple, MeshComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimple::MeshComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimple, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimple::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimple, SwitchValue) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimple::SwitchValue' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimple, SocketBeginOffset) == 0x000020, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimple::SocketBeginOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimple, SocketEndOffset) == 0x00002C, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimple::SocketEndOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimple, SocketHalfSize) == 0x000038, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimple::SocketHalfSize' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimple, AkObject) == 0x000048, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimple::AkObject' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.FootstepSimpleRusher
// 0x00D0 (0x00D0 - 0x0000)
struct PhxSoundAnimNotifyLibrary_FootstepSimpleRusher final
{
public:
	class USkeletalMeshComponent*                 MeshComponent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkSwitchValue*                         FootSwitch;                                        // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                BeginOffset;                                       // 0x0020(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                EndOffset;                                         // 0x002C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x0038(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             OutHit;                                            // 0x003C(0x0088)(Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_C4[0x4];                                       // 0x00C4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UAkComponent*                           ReturnValue;                                       // 0x00C8(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_FootstepSimpleRusher");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher) == 0x0000D0, "Wrong size on PhxSoundAnimNotifyLibrary_FootstepSimpleRusher");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher, MeshComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimpleRusher::MeshComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimpleRusher::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher, FootSwitch) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimpleRusher::FootSwitch' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher, BeginOffset) == 0x000020, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimpleRusher::BeginOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher, EndOffset) == 0x00002C, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimpleRusher::EndOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher, Radius) == 0x000038, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimpleRusher::Radius' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher, OutHit) == 0x00003C, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimpleRusher::OutHit' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_FootstepSimpleRusher, ReturnValue) == 0x0000C8, "Member 'PhxSoundAnimNotifyLibrary_FootstepSimpleRusher::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.HandPatSkeletonCheckSound
// 0x0050 (0x0050 - 0x0000)
struct PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound final
{
public:
	class USkeletalMeshComponent*                 MeshComponent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkComponent*                           SoundComponent;                                    // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 DefaultHandsSwitchGroup;                           // 0x0020(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketBeginOffset;                                 // 0x0030(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                SocketEndOffset;                                   // 0x003C(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x0048(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x004C(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4D[0x3];                                       // 0x004D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound) == 0x000050, "Wrong size on PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound, MeshComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound::MeshComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound, SoundComponent) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound::SoundComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound, DefaultHandsSwitchGroup) == 0x000020, "Member 'PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound::DefaultHandsSwitchGroup' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound, SocketBeginOffset) == 0x000030, "Member 'PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound::SocketBeginOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound, SocketEndOffset) == 0x00003C, "Member 'PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound::SocketEndOffset' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound, Radius) == 0x000048, "Member 'PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound::Radius' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound, ReturnValue) == 0x00004C, "Member 'PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.MovementSkeletonCheckSound
// 0x0040 (0x0040 - 0x0000)
struct PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound final
{
public:
	class USkeletalMeshComponent*                 MeshComponent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkSwitchValue*                         SwitchValue;                                       // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 TargetSkeletonName;                                // 0x0020(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAkComponent*                           SoundComponent;                                    // 0x0030(0x0008)(Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0038(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound) == 0x000040, "Wrong size on PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound, MeshComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound::MeshComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound, SwitchValue) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound::SwitchValue' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound, TargetSkeletonName) == 0x000020, "Member 'PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound::TargetSkeletonName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound, SoundComponent) == 0x000030, "Member 'PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound::SoundComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound, ReturnValue) == 0x000038, "Member 'PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.PickupMaterialCheckSound
// 0x0020 (0x0020 - 0x0000)
struct PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound final
{
public:
	class USkeletalMeshComponent*                 MeshComponent;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AttachName;                                        // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound) == 0x000020, "Wrong size on PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound, MeshComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound::MeshComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound, AttachName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound::AttachName' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound, Radius) == 0x000018, "Member 'PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound::Radius' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.SetFootstepMaterialSwitch
// 0x0018 (0x0018 - 0x0000)
struct PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch final
{
public:
	class UAkComponent*                           AkComponent;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 PhysMaterialName;                                  // 0x0008(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch) == 0x000018, "Wrong size on PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch, AkComponent) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch::AkComponent' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch, PhysMaterialName) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch::PhysMaterialName' has a wrong offset!");

// Function Phoenix.PhxSoundAnimNotifyLibrary.SkeletonCheck
// 0x0010 (0x0010 - 0x0000)
struct PhxSoundAnimNotifyLibrary_SkeletonCheck final
{
public:
	const class USkinnedMeshComponent*            SkinnedMesh;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          PlayerGruntBareLeftBootRight;                      // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          GruntBareLeftBareRight;                            // 0x0009(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          GruntBootLeftBootRight;                            // 0x000A(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          Grunt;                                             // 0x000B(0x0001)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundAnimNotifyLibrary_SkeletonCheck) == 0x000008, "Wrong alignment on PhxSoundAnimNotifyLibrary_SkeletonCheck");
static_assert(sizeof(PhxSoundAnimNotifyLibrary_SkeletonCheck) == 0x000010, "Wrong size on PhxSoundAnimNotifyLibrary_SkeletonCheck");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_SkeletonCheck, SkinnedMesh) == 0x000000, "Member 'PhxSoundAnimNotifyLibrary_SkeletonCheck::SkinnedMesh' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_SkeletonCheck, PlayerGruntBareLeftBootRight) == 0x000008, "Member 'PhxSoundAnimNotifyLibrary_SkeletonCheck::PlayerGruntBareLeftBootRight' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_SkeletonCheck, GruntBareLeftBareRight) == 0x000009, "Member 'PhxSoundAnimNotifyLibrary_SkeletonCheck::GruntBareLeftBareRight' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_SkeletonCheck, GruntBootLeftBootRight) == 0x00000A, "Member 'PhxSoundAnimNotifyLibrary_SkeletonCheck::GruntBootLeftBootRight' has a wrong offset!");
static_assert(offsetof(PhxSoundAnimNotifyLibrary_SkeletonCheck, Grunt) == 0x00000B, "Member 'PhxSoundAnimNotifyLibrary_SkeletonCheck::Grunt' has a wrong offset!");

// Function Phoenix.PhxSoundComponent.PhxSetSwitch
// 0x0030 (0x0030 - 0x0000)
struct PhxSoundComponent_PhxSetSwitch final
{
public:
	class FString                                 WorkUnitString;                                    // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 SwitchGroupString;                                 // 0x0010(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 SwitchValue;                                       // 0x0020(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundComponent_PhxSetSwitch) == 0x000008, "Wrong alignment on PhxSoundComponent_PhxSetSwitch");
static_assert(sizeof(PhxSoundComponent_PhxSetSwitch) == 0x000030, "Wrong size on PhxSoundComponent_PhxSetSwitch");
static_assert(offsetof(PhxSoundComponent_PhxSetSwitch, WorkUnitString) == 0x000000, "Member 'PhxSoundComponent_PhxSetSwitch::WorkUnitString' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PhxSetSwitch, SwitchGroupString) == 0x000010, "Member 'PhxSoundComponent_PhxSetSwitch::SwitchGroupString' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PhxSetSwitch, SwitchValue) == 0x000020, "Member 'PhxSoundComponent_PhxSetSwitch::SwitchValue' has a wrong offset!");

// Function Phoenix.PhxSoundComponent.PostForcedSoundEvent
// 0x0010 (0x0010 - 0x0000)
struct PhxSoundComponent_PostForcedSoundEvent final
{
public:
	class UAkAudioEvent*                          AkEvent;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundComponent_PostForcedSoundEvent) == 0x000008, "Wrong alignment on PhxSoundComponent_PostForcedSoundEvent");
static_assert(sizeof(PhxSoundComponent_PostForcedSoundEvent) == 0x000010, "Wrong size on PhxSoundComponent_PostForcedSoundEvent");
static_assert(offsetof(PhxSoundComponent_PostForcedSoundEvent, AkEvent) == 0x000000, "Member 'PhxSoundComponent_PostForcedSoundEvent::AkEvent' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostForcedSoundEvent, ReturnValue) == 0x000008, "Member 'PhxSoundComponent_PostForcedSoundEvent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundComponent.PostForcedSoundEventWithCallbackLocal
// 0x0028 (0x0028 - 0x0000)
struct PhxSoundComponent_PostForcedSoundEventWithCallbackLocal final
{
public:
	class UAkAudioEvent*                          Event;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bStopOnDestroy;                                    // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         CallbackMask;                                      // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)> PostEventCallback; // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0020(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundComponent_PostForcedSoundEventWithCallbackLocal) == 0x000008, "Wrong alignment on PhxSoundComponent_PostForcedSoundEventWithCallbackLocal");
static_assert(sizeof(PhxSoundComponent_PostForcedSoundEventWithCallbackLocal) == 0x000028, "Wrong size on PhxSoundComponent_PostForcedSoundEventWithCallbackLocal");
static_assert(offsetof(PhxSoundComponent_PostForcedSoundEventWithCallbackLocal, Event) == 0x000000, "Member 'PhxSoundComponent_PostForcedSoundEventWithCallbackLocal::Event' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostForcedSoundEventWithCallbackLocal, bStopOnDestroy) == 0x000008, "Member 'PhxSoundComponent_PostForcedSoundEventWithCallbackLocal::bStopOnDestroy' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostForcedSoundEventWithCallbackLocal, CallbackMask) == 0x00000C, "Member 'PhxSoundComponent_PostForcedSoundEventWithCallbackLocal::CallbackMask' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostForcedSoundEventWithCallbackLocal, PostEventCallback) == 0x000010, "Member 'PhxSoundComponent_PostForcedSoundEventWithCallbackLocal::PostEventCallback' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostForcedSoundEventWithCallbackLocal, ReturnValue) == 0x000020, "Member 'PhxSoundComponent_PostForcedSoundEventWithCallbackLocal::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundComponent.PostSoundEvent
// 0x0010 (0x0010 - 0x0000)
struct PhxSoundComponent_PostSoundEvent final
{
public:
	class UAkAudioEvent*                          AkEvent;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundComponent_PostSoundEvent) == 0x000008, "Wrong alignment on PhxSoundComponent_PostSoundEvent");
static_assert(sizeof(PhxSoundComponent_PostSoundEvent) == 0x000010, "Wrong size on PhxSoundComponent_PostSoundEvent");
static_assert(offsetof(PhxSoundComponent_PostSoundEvent, AkEvent) == 0x000000, "Member 'PhxSoundComponent_PostSoundEvent::AkEvent' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostSoundEvent, ReturnValue) == 0x000008, "Member 'PhxSoundComponent_PostSoundEvent::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundComponent.PostSoundEventWithCallbackLocal
// 0x0028 (0x0028 - 0x0000)
struct PhxSoundComponent_PostSoundEventWithCallbackLocal final
{
public:
	class UAkAudioEvent*                          Event;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bStopOnDestroy;                                    // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         CallbackMask;                                      // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)> PostEventCallback; // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0020(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSoundComponent_PostSoundEventWithCallbackLocal) == 0x000008, "Wrong alignment on PhxSoundComponent_PostSoundEventWithCallbackLocal");
static_assert(sizeof(PhxSoundComponent_PostSoundEventWithCallbackLocal) == 0x000028, "Wrong size on PhxSoundComponent_PostSoundEventWithCallbackLocal");
static_assert(offsetof(PhxSoundComponent_PostSoundEventWithCallbackLocal, Event) == 0x000000, "Member 'PhxSoundComponent_PostSoundEventWithCallbackLocal::Event' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostSoundEventWithCallbackLocal, bStopOnDestroy) == 0x000008, "Member 'PhxSoundComponent_PostSoundEventWithCallbackLocal::bStopOnDestroy' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostSoundEventWithCallbackLocal, CallbackMask) == 0x00000C, "Member 'PhxSoundComponent_PostSoundEventWithCallbackLocal::CallbackMask' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostSoundEventWithCallbackLocal, PostEventCallback) == 0x000010, "Member 'PhxSoundComponent_PostSoundEventWithCallbackLocal::PostEventCallback' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_PostSoundEventWithCallbackLocal, ReturnValue) == 0x000020, "Member 'PhxSoundComponent_PostSoundEventWithCallbackLocal::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSoundComponent.StopSound
// 0x0008 (0x0008 - 0x0000)
struct PhxSoundComponent_StopSound final
{
public:
	int32                                         PlayingSoundId;                                    // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeTime;                                          // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundComponent_StopSound) == 0x000004, "Wrong alignment on PhxSoundComponent_StopSound");
static_assert(sizeof(PhxSoundComponent_StopSound) == 0x000008, "Wrong size on PhxSoundComponent_StopSound");
static_assert(offsetof(PhxSoundComponent_StopSound, PlayingSoundId) == 0x000000, "Member 'PhxSoundComponent_StopSound::PlayingSoundId' has a wrong offset!");
static_assert(offsetof(PhxSoundComponent_StopSound, FadeTime) == 0x000004, "Member 'PhxSoundComponent_StopSound::FadeTime' has a wrong offset!");

// Function Phoenix.PhxSoundComponent.GetLastPostedSound
// 0x0004 (0x0004 - 0x0000)
struct PhxSoundComponent_GetLastPostedSound final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSoundComponent_GetLastPostedSound) == 0x000004, "Wrong alignment on PhxSoundComponent_GetLastPostedSound");
static_assert(sizeof(PhxSoundComponent_GetLastPostedSound) == 0x000004, "Wrong size on PhxSoundComponent_GetLastPostedSound");
static_assert(offsetof(PhxSoundComponent_GetLastPostedSound, ReturnValue) == 0x000000, "Member 'PhxSoundComponent_GetLastPostedSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetPlayerWalksAwayFromMachineSound
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetPlayerWalksAwayFromMachineSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetPlayerWalksAwayFromMachineSound) == 0x000008, "Wrong alignment on PrinterV2_GetPlayerWalksAwayFromMachineSound");
static_assert(sizeof(PrinterV2_GetPlayerWalksAwayFromMachineSound) == 0x000008, "Wrong size on PrinterV2_GetPlayerWalksAwayFromMachineSound");
static_assert(offsetof(PrinterV2_GetPlayerWalksAwayFromMachineSound, ReturnValue) == 0x000000, "Member 'PrinterV2_GetPlayerWalksAwayFromMachineSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.Print
// 0x0108 (0x0108 - 0x0000)
struct PrinterV2_Print final
{
public:
	struct FItemData                              ItemData;                                          // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	int32                                         NumOfStacks;                                       // 0x0100(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_104[0x4];                                      // 0x0104(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PrinterV2_Print) == 0x000008, "Wrong alignment on PrinterV2_Print");
static_assert(sizeof(PrinterV2_Print) == 0x000108, "Wrong size on PrinterV2_Print");
static_assert(offsetof(PrinterV2_Print, ItemData) == 0x000000, "Member 'PrinterV2_Print::ItemData' has a wrong offset!");
static_assert(offsetof(PrinterV2_Print, NumOfStacks) == 0x000100, "Member 'PrinterV2_Print::NumOfStacks' has a wrong offset!");

// Function Phoenix.PrinterV2.PrinterStateChanged
// 0x0018 (0x0018 - 0x0000)
struct PrinterV2_PrinterStateChanged final
{
public:
	class UState*                                 Sender;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UState*                                 LastState;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UState*                                 NextState;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_PrinterStateChanged) == 0x000008, "Wrong alignment on PrinterV2_PrinterStateChanged");
static_assert(sizeof(PrinterV2_PrinterStateChanged) == 0x000018, "Wrong size on PrinterV2_PrinterStateChanged");
static_assert(offsetof(PrinterV2_PrinterStateChanged, Sender) == 0x000000, "Member 'PrinterV2_PrinterStateChanged::Sender' has a wrong offset!");
static_assert(offsetof(PrinterV2_PrinterStateChanged, LastState) == 0x000008, "Member 'PrinterV2_PrinterStateChanged::LastState' has a wrong offset!");
static_assert(offsetof(PrinterV2_PrinterStateChanged, NextState) == 0x000010, "Member 'PrinterV2_PrinterStateChanged::NextState' has a wrong offset!");

// Function Phoenix.PrinterV2.SetBuyUIVisibility
// 0x0001 (0x0001 - 0x0000)
struct PrinterV2_SetBuyUIVisibility final
{
public:
	bool                                          bVisible;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_SetBuyUIVisibility) == 0x000001, "Wrong alignment on PrinterV2_SetBuyUIVisibility");
static_assert(sizeof(PrinterV2_SetBuyUIVisibility) == 0x000001, "Wrong size on PrinterV2_SetBuyUIVisibility");
static_assert(offsetof(PrinterV2_SetBuyUIVisibility, bVisible) == 0x000000, "Member 'PrinterV2_SetBuyUIVisibility::bVisible' has a wrong offset!");

// Function Phoenix.PrinterV2.Upgrade
// 0x0010 (0x0010 - 0x0000)
struct PrinterV2_Upgrade final
{
public:
	class AEquippable*                            ItemToUpgrade;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxCraftingRecipe*               InRecipe;                                          // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_Upgrade) == 0x000008, "Wrong alignment on PrinterV2_Upgrade");
static_assert(sizeof(PrinterV2_Upgrade) == 0x000010, "Wrong size on PrinterV2_Upgrade");
static_assert(offsetof(PrinterV2_Upgrade, ItemToUpgrade) == 0x000000, "Member 'PrinterV2_Upgrade::ItemToUpgrade' has a wrong offset!");
static_assert(offsetof(PrinterV2_Upgrade, InRecipe) == 0x000008, "Member 'PrinterV2_Upgrade::InRecipe' has a wrong offset!");

// Function Phoenix.PrinterV2.CalculatePriceWithDiscount
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_CalculatePriceWithDiscount final
{
public:
	int32                                         BasePrice;                                         // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_CalculatePriceWithDiscount) == 0x000004, "Wrong alignment on PrinterV2_CalculatePriceWithDiscount");
static_assert(sizeof(PrinterV2_CalculatePriceWithDiscount) == 0x000008, "Wrong size on PrinterV2_CalculatePriceWithDiscount");
static_assert(offsetof(PrinterV2_CalculatePriceWithDiscount, BasePrice) == 0x000000, "Member 'PrinterV2_CalculatePriceWithDiscount::BasePrice' has a wrong offset!");
static_assert(offsetof(PrinterV2_CalculatePriceWithDiscount, ReturnValue) == 0x000004, "Member 'PrinterV2_CalculatePriceWithDiscount::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetDiscount
// 0x0004 (0x0004 - 0x0000)
struct PrinterV2_GetDiscount final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetDiscount) == 0x000004, "Wrong alignment on PrinterV2_GetDiscount");
static_assert(sizeof(PrinterV2_GetDiscount) == 0x000004, "Wrong size on PrinterV2_GetDiscount");
static_assert(offsetof(PrinterV2_GetDiscount, ReturnValue) == 0x000000, "Member 'PrinterV2_GetDiscount::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetPlayerApproachesMachineSound
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetPlayerApproachesMachineSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetPlayerApproachesMachineSound) == 0x000008, "Wrong alignment on PrinterV2_GetPlayerApproachesMachineSound");
static_assert(sizeof(PrinterV2_GetPlayerApproachesMachineSound) == 0x000008, "Wrong size on PrinterV2_GetPlayerApproachesMachineSound");
static_assert(offsetof(PrinterV2_GetPlayerApproachesMachineSound, ReturnValue) == 0x000000, "Member 'PrinterV2_GetPlayerApproachesMachineSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetSoundComp
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetSoundComp final
{
public:
	class UPhxSoundComponent*                     ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetSoundComp) == 0x000008, "Wrong alignment on PrinterV2_GetSoundComp");
static_assert(sizeof(PrinterV2_GetSoundComp) == 0x000008, "Wrong size on PrinterV2_GetSoundComp");
static_assert(offsetof(PrinterV2_GetSoundComp, ReturnValue) == 0x000000, "Member 'PrinterV2_GetSoundComp::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetUICancelSound
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetUICancelSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetUICancelSound) == 0x000008, "Wrong alignment on PrinterV2_GetUICancelSound");
static_assert(sizeof(PrinterV2_GetUICancelSound) == 0x000008, "Wrong size on PrinterV2_GetUICancelSound");
static_assert(offsetof(PrinterV2_GetUICancelSound, ReturnValue) == 0x000000, "Member 'PrinterV2_GetUICancelSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetUIConfirmSound
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetUIConfirmSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetUIConfirmSound) == 0x000008, "Wrong alignment on PrinterV2_GetUIConfirmSound");
static_assert(sizeof(PrinterV2_GetUIConfirmSound) == 0x000008, "Wrong size on PrinterV2_GetUIConfirmSound");
static_assert(offsetof(PrinterV2_GetUIConfirmSound, ReturnValue) == 0x000000, "Member 'PrinterV2_GetUIConfirmSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetUIErrorSound
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetUIErrorSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetUIErrorSound) == 0x000008, "Wrong alignment on PrinterV2_GetUIErrorSound");
static_assert(sizeof(PrinterV2_GetUIErrorSound) == 0x000008, "Wrong size on PrinterV2_GetUIErrorSound");
static_assert(offsetof(PrinterV2_GetUIErrorSound, ReturnValue) == 0x000000, "Member 'PrinterV2_GetUIErrorSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetUISweepDownSound
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetUISweepDownSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetUISweepDownSound) == 0x000008, "Wrong alignment on PrinterV2_GetUISweepDownSound");
static_assert(sizeof(PrinterV2_GetUISweepDownSound) == 0x000008, "Wrong size on PrinterV2_GetUISweepDownSound");
static_assert(offsetof(PrinterV2_GetUISweepDownSound, ReturnValue) == 0x000000, "Member 'PrinterV2_GetUISweepDownSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetUISweepLeftSound
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetUISweepLeftSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetUISweepLeftSound) == 0x000008, "Wrong alignment on PrinterV2_GetUISweepLeftSound");
static_assert(sizeof(PrinterV2_GetUISweepLeftSound) == 0x000008, "Wrong size on PrinterV2_GetUISweepLeftSound");
static_assert(offsetof(PrinterV2_GetUISweepLeftSound, ReturnValue) == 0x000000, "Member 'PrinterV2_GetUISweepLeftSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetUISweepRightSound
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetUISweepRightSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetUISweepRightSound) == 0x000008, "Wrong alignment on PrinterV2_GetUISweepRightSound");
static_assert(sizeof(PrinterV2_GetUISweepRightSound) == 0x000008, "Wrong size on PrinterV2_GetUISweepRightSound");
static_assert(offsetof(PrinterV2_GetUISweepRightSound, ReturnValue) == 0x000000, "Member 'PrinterV2_GetUISweepRightSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.GetUISweepUpSound
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2_GetUISweepUpSound final
{
public:
	class UAkAudioEvent*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_GetUISweepUpSound) == 0x000008, "Wrong alignment on PrinterV2_GetUISweepUpSound");
static_assert(sizeof(PrinterV2_GetUISweepUpSound) == 0x000008, "Wrong size on PrinterV2_GetUISweepUpSound");
static_assert(offsetof(PrinterV2_GetUISweepUpSound, ReturnValue) == 0x000000, "Member 'PrinterV2_GetUISweepUpSound::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterV2.IsReadyForUsage
// 0x0001 (0x0001 - 0x0000)
struct PrinterV2_IsReadyForUsage final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2_IsReadyForUsage) == 0x000001, "Wrong alignment on PrinterV2_IsReadyForUsage");
static_assert(sizeof(PrinterV2_IsReadyForUsage) == 0x000001, "Wrong size on PrinterV2_IsReadyForUsage");
static_assert(offsetof(PrinterV2_IsReadyForUsage, ReturnValue) == 0x000000, "Member 'PrinterV2_IsReadyForUsage::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSplineComponent.AddNewModifier
// 0x0010 (0x0010 - 0x0000)
struct PhxSplineComponent_AddNewModifier final
{
public:
	TSubclassOf<class UPhxSplineModifier>         ModifierClass;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxSplineModifier*                     ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSplineComponent_AddNewModifier) == 0x000008, "Wrong alignment on PhxSplineComponent_AddNewModifier");
static_assert(sizeof(PhxSplineComponent_AddNewModifier) == 0x000010, "Wrong size on PhxSplineComponent_AddNewModifier");
static_assert(offsetof(PhxSplineComponent_AddNewModifier, ModifierClass) == 0x000000, "Member 'PhxSplineComponent_AddNewModifier::ModifierClass' has a wrong offset!");
static_assert(offsetof(PhxSplineComponent_AddNewModifier, ReturnValue) == 0x000008, "Member 'PhxSplineComponent_AddNewModifier::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSplineComponent.RemoveModifier
// 0x0008 (0x0008 - 0x0000)
struct PhxSplineComponent_RemoveModifier final
{
public:
	class UPhxSplineModifier*                     ModifierToRemove;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSplineComponent_RemoveModifier) == 0x000008, "Wrong alignment on PhxSplineComponent_RemoveModifier");
static_assert(sizeof(PhxSplineComponent_RemoveModifier) == 0x000008, "Wrong size on PhxSplineComponent_RemoveModifier");
static_assert(offsetof(PhxSplineComponent_RemoveModifier, ModifierToRemove) == 0x000000, "Member 'PhxSplineComponent_RemoveModifier::ModifierToRemove' has a wrong offset!");

// Function Phoenix.PhxSplineUtil.ApproximateNearestDistanceAlongSpline
// 0x0020 (0x0020 - 0x0000)
struct PhxSplineUtil_ApproximateNearestDistanceAlongSpline final
{
public:
	const class USplineComponent*                 Spline;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                WorldLocation;                                     // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         recursionDepth;                                    // 0x0014(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0018(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxSplineUtil_ApproximateNearestDistanceAlongSpline) == 0x000008, "Wrong alignment on PhxSplineUtil_ApproximateNearestDistanceAlongSpline");
static_assert(sizeof(PhxSplineUtil_ApproximateNearestDistanceAlongSpline) == 0x000020, "Wrong size on PhxSplineUtil_ApproximateNearestDistanceAlongSpline");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestDistanceAlongSpline, Spline) == 0x000000, "Member 'PhxSplineUtil_ApproximateNearestDistanceAlongSpline::Spline' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestDistanceAlongSpline, WorldLocation) == 0x000008, "Member 'PhxSplineUtil_ApproximateNearestDistanceAlongSpline::WorldLocation' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestDistanceAlongSpline, recursionDepth) == 0x000014, "Member 'PhxSplineUtil_ApproximateNearestDistanceAlongSpline::recursionDepth' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestDistanceAlongSpline, ReturnValue) == 0x000018, "Member 'PhxSplineUtil_ApproximateNearestDistanceAlongSpline::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSplineUtil.ApproximateNearestLocationAlongSpline
// 0x0020 (0x0020 - 0x0000)
struct PhxSplineUtil_ApproximateNearestLocationAlongSpline final
{
public:
	const class USplineComponent*                 Spline;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                WorldLocation;                                     // 0x0008(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x0014(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSplineUtil_ApproximateNearestLocationAlongSpline) == 0x000008, "Wrong alignment on PhxSplineUtil_ApproximateNearestLocationAlongSpline");
static_assert(sizeof(PhxSplineUtil_ApproximateNearestLocationAlongSpline) == 0x000020, "Wrong size on PhxSplineUtil_ApproximateNearestLocationAlongSpline");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationAlongSpline, Spline) == 0x000000, "Member 'PhxSplineUtil_ApproximateNearestLocationAlongSpline::Spline' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationAlongSpline, WorldLocation) == 0x000008, "Member 'PhxSplineUtil_ApproximateNearestLocationAlongSpline::WorldLocation' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationAlongSpline, ReturnValue) == 0x000014, "Member 'PhxSplineUtil_ApproximateNearestLocationAlongSpline::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSplineUtil.ApproximateNearestLocationToActorAlongSpline
// 0x0028 (0x0028 - 0x0000)
struct PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline final
{
public:
	const class USplineComponent*                 Spline;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class AActor*                           Actor;                                             // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                actorToSpline;                                     // 0x0010(0x000C)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x001C(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline) == 0x000008, "Wrong alignment on PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline");
static_assert(sizeof(PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline) == 0x000028, "Wrong size on PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline, Spline) == 0x000000, "Member 'PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline::Spline' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline, Actor) == 0x000008, "Member 'PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline::Actor' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline, actorToSpline) == 0x000010, "Member 'PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline::actorToSpline' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline, ReturnValue) == 0x00001C, "Member 'PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxSplineUtil.ApproximateNearestLocationToComponentAlongSpline
// 0x0028 (0x0028 - 0x0000)
struct PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline final
{
public:
	const class USplineComponent*                 Spline;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class USceneComponent*                  Component;                                         // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                componentToSpline;                                 // 0x0010(0x000C)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ReturnValue;                                       // 0x001C(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline) == 0x000008, "Wrong alignment on PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline");
static_assert(sizeof(PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline) == 0x000028, "Wrong size on PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline, Spline) == 0x000000, "Member 'PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline::Spline' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline, Component) == 0x000008, "Member 'PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline::Component' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline, componentToSpline) == 0x000010, "Member 'PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline::componentToSpline' has a wrong offset!");
static_assert(offsetof(PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline, ReturnValue) == 0x00001C, "Member 'PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxStompableComponent.IncreaseStompCount
// 0x0004 (0x0004 - 0x0000)
struct PhxStompableComponent_IncreaseStompCount final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxStompableComponent_IncreaseStompCount) == 0x000004, "Wrong alignment on PhxStompableComponent_IncreaseStompCount");
static_assert(sizeof(PhxStompableComponent_IncreaseStompCount) == 0x000004, "Wrong size on PhxStompableComponent_IncreaseStompCount");
static_assert(offsetof(PhxStompableComponent_IncreaseStompCount, ReturnValue) == 0x000000, "Member 'PhxStompableComponent_IncreaseStompCount::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxStompableComponent.SetCanTakeStompDamage
// 0x0001 (0x0001 - 0x0000)
struct PhxStompableComponent_SetCanTakeStompDamage final
{
public:
	bool                                          bCanBeDamaged;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxStompableComponent_SetCanTakeStompDamage) == 0x000001, "Wrong alignment on PhxStompableComponent_SetCanTakeStompDamage");
static_assert(sizeof(PhxStompableComponent_SetCanTakeStompDamage) == 0x000001, "Wrong size on PhxStompableComponent_SetCanTakeStompDamage");
static_assert(offsetof(PhxStompableComponent_SetCanTakeStompDamage, bCanBeDamaged) == 0x000000, "Member 'PhxStompableComponent_SetCanTakeStompDamage::bCanBeDamaged' has a wrong offset!");

// Function Phoenix.PhxStompableComponent.CanTakeStompDamage
// 0x0001 (0x0001 - 0x0000)
struct PhxStompableComponent_CanTakeStompDamage final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxStompableComponent_CanTakeStompDamage) == 0x000001, "Wrong alignment on PhxStompableComponent_CanTakeStompDamage");
static_assert(sizeof(PhxStompableComponent_CanTakeStompDamage) == 0x000001, "Wrong size on PhxStompableComponent_CanTakeStompDamage");
static_assert(offsetof(PhxStompableComponent_CanTakeStompDamage, ReturnValue) == 0x000000, "Member 'PhxStompableComponent_CanTakeStompDamage::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxStompableComponent.GetStompCount
// 0x0004 (0x0004 - 0x0000)
struct PhxStompableComponent_GetStompCount final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxStompableComponent_GetStompCount) == 0x000004, "Wrong alignment on PhxStompableComponent_GetStompCount");
static_assert(sizeof(PhxStompableComponent_GetStompCount) == 0x000004, "Wrong size on PhxStompableComponent_GetStompCount");
static_assert(offsetof(PhxStompableComponent_GetStompCount, ReturnValue) == 0x000000, "Member 'PhxStompableComponent_GetStompCount::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.Get
// 0x0010 (0x0010 - 0x0000)
struct PhxTelemetryManager_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhxTelemetryManager*                   ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_Get) == 0x000008, "Wrong alignment on PhxTelemetryManager_Get");
static_assert(sizeof(PhxTelemetryManager_Get) == 0x000010, "Wrong size on PhxTelemetryManager_Get");
static_assert(offsetof(PhxTelemetryManager_Get, WorldContextObject) == 0x000000, "Member 'PhxTelemetryManager_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_Get, ReturnValue) == 0x000008, "Member 'PhxTelemetryManager_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.SendFinishGameTelemetry
// 0x0008 (0x0008 - 0x0000)
struct PhxTelemetryManager_SendFinishGameTelemetry final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_SendFinishGameTelemetry) == 0x000008, "Wrong alignment on PhxTelemetryManager_SendFinishGameTelemetry");
static_assert(sizeof(PhxTelemetryManager_SendFinishGameTelemetry) == 0x000008, "Wrong size on PhxTelemetryManager_SendFinishGameTelemetry");
static_assert(offsetof(PhxTelemetryManager_SendFinishGameTelemetry, WorldContextObject) == 0x000000, "Member 'PhxTelemetryManager_SendFinishGameTelemetry::WorldContextObject' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnCheckpointRecorded
// 0x0008 (0x0008 - 0x0000)
struct PhxTelemetryManager_OnCheckpointRecorded final
{
public:
	class ACheckpoint*                            RecordedCheckpoint;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnCheckpointRecorded) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnCheckpointRecorded");
static_assert(sizeof(PhxTelemetryManager_OnCheckpointRecorded) == 0x000008, "Wrong size on PhxTelemetryManager_OnCheckpointRecorded");
static_assert(offsetof(PhxTelemetryManager_OnCheckpointRecorded, RecordedCheckpoint) == 0x000000, "Member 'PhxTelemetryManager_OnCheckpointRecorded::RecordedCheckpoint' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnDefensiveAction
// 0x0100 (0x0100 - 0x0000)
struct PhxTelemetryManager_OnDefensiveAction final
{
public:
	EReactionType                                 ReactionType;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefensiveReactDirection                      ReactionDir;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2[0x6];                                        // 0x0002(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitRecord                             HitRecord;                                         // 0x0008(0x00F8)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnDefensiveAction) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnDefensiveAction");
static_assert(sizeof(PhxTelemetryManager_OnDefensiveAction) == 0x000100, "Wrong size on PhxTelemetryManager_OnDefensiveAction");
static_assert(offsetof(PhxTelemetryManager_OnDefensiveAction, ReactionType) == 0x000000, "Member 'PhxTelemetryManager_OnDefensiveAction::ReactionType' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnDefensiveAction, ReactionDir) == 0x000001, "Member 'PhxTelemetryManager_OnDefensiveAction::ReactionDir' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnDefensiveAction, HitRecord) == 0x000008, "Member 'PhxTelemetryManager_OnDefensiveAction::HitRecord' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnEnemyDeath
// 0x0018 (0x0018 - 0x0000)
struct PhxTelemetryManager_OnEnemyDeath final
{
public:
	class UPhxAIGameStateManager*                 GameStateManager;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxAICharacter*                        Enemy;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnEnemyDeath) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnEnemyDeath");
static_assert(sizeof(PhxTelemetryManager_OnEnemyDeath) == 0x000018, "Wrong size on PhxTelemetryManager_OnEnemyDeath");
static_assert(offsetof(PhxTelemetryManager_OnEnemyDeath, GameStateManager) == 0x000000, "Member 'PhxTelemetryManager_OnEnemyDeath::GameStateManager' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnEnemyDeath, Enemy) == 0x000008, "Member 'PhxTelemetryManager_OnEnemyDeath::Enemy' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnEnemyDeath, KillerController) == 0x000010, "Member 'PhxTelemetryManager_OnEnemyDeath::KillerController' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnEnterSpace
// 0x0008 (0x0008 - 0x0000)
struct PhxTelemetryManager_OnEnterSpace final
{
public:
	const class APhxLevelPacingMeterSpace*        Space;                                             // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnEnterSpace) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnEnterSpace");
static_assert(sizeof(PhxTelemetryManager_OnEnterSpace) == 0x000008, "Wrong size on PhxTelemetryManager_OnEnterSpace");
static_assert(offsetof(PhxTelemetryManager_OnEnterSpace, Space) == 0x000000, "Member 'PhxTelemetryManager_OnEnterSpace::Space' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnExitSpace
// 0x0010 (0x0010 - 0x0000)
struct PhxTelemetryManager_OnExitSpace final
{
public:
	const class APhxLevelPacingMeterSpace*        Space;                                             // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimeSpentInSpace;                                  // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxTelemetryManager_OnExitSpace) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnExitSpace");
static_assert(sizeof(PhxTelemetryManager_OnExitSpace) == 0x000010, "Wrong size on PhxTelemetryManager_OnExitSpace");
static_assert(offsetof(PhxTelemetryManager_OnExitSpace, Space) == 0x000000, "Member 'PhxTelemetryManager_OnExitSpace::Space' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnExitSpace, TimeSpentInSpace) == 0x000008, "Member 'PhxTelemetryManager_OnExitSpace::TimeSpentInSpace' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnHitRecorded
// 0x0108 (0x0108 - 0x0000)
struct PhxTelemetryManager_OnHitRecorded final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class UPhxCharacterHealthComponent*     HealthComponent;                                   // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitRecord                             HitRecord;                                         // 0x0010(0x00F8)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnHitRecorded) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnHitRecorded");
static_assert(sizeof(PhxTelemetryManager_OnHitRecorded) == 0x000108, "Wrong size on PhxTelemetryManager_OnHitRecorded");
static_assert(offsetof(PhxTelemetryManager_OnHitRecorded, Character) == 0x000000, "Member 'PhxTelemetryManager_OnHitRecorded::Character' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnHitRecorded, HealthComponent) == 0x000008, "Member 'PhxTelemetryManager_OnHitRecorded::HealthComponent' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnHitRecorded, HitRecord) == 0x000010, "Member 'PhxTelemetryManager_OnHitRecorded::HitRecord' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnMapEndLoad
// 0x0008 (0x0008 - 0x0000)
struct PhxTelemetryManager_OnMapEndLoad final
{
public:
	class UWorld*                                 World;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnMapEndLoad) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnMapEndLoad");
static_assert(sizeof(PhxTelemetryManager_OnMapEndLoad) == 0x000008, "Wrong size on PhxTelemetryManager_OnMapEndLoad");
static_assert(offsetof(PhxTelemetryManager_OnMapEndLoad, World) == 0x000000, "Member 'PhxTelemetryManager_OnMapEndLoad::World' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnMapStartLoad
// 0x0010 (0x0010 - 0x0000)
struct PhxTelemetryManager_OnMapStartLoad final
{
public:
	class FString                                 MapPath;                                           // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnMapStartLoad) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnMapStartLoad");
static_assert(sizeof(PhxTelemetryManager_OnMapStartLoad) == 0x000010, "Wrong size on PhxTelemetryManager_OnMapStartLoad");
static_assert(offsetof(PhxTelemetryManager_OnMapStartLoad, MapPath) == 0x000000, "Member 'PhxTelemetryManager_OnMapStartLoad::MapPath' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnMeleeAttack
// 0x0018 (0x0018 - 0x0000)
struct PhxTelemetryManager_OnMeleeAttack final
{
public:
	const class UMeleeAttackState*                MeleeAttackState;                                  // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class APhxCharacter*                    SourceCharacter;                                   // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class APhxCharacter*                    TargetCharacter;                                   // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnMeleeAttack) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnMeleeAttack");
static_assert(sizeof(PhxTelemetryManager_OnMeleeAttack) == 0x000018, "Wrong size on PhxTelemetryManager_OnMeleeAttack");
static_assert(offsetof(PhxTelemetryManager_OnMeleeAttack, MeleeAttackState) == 0x000000, "Member 'PhxTelemetryManager_OnMeleeAttack::MeleeAttackState' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnMeleeAttack, SourceCharacter) == 0x000008, "Member 'PhxTelemetryManager_OnMeleeAttack::SourceCharacter' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnMeleeAttack, TargetCharacter) == 0x000010, "Member 'PhxTelemetryManager_OnMeleeAttack::TargetCharacter' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnPlayerDeath
// 0x0020 (0x0020 - 0x0000)
struct PhxTelemetryManager_OnPlayerDeath final
{
public:
	class APhxCharacter*                          DeadCharacter;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 KillerActor;                                       // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            KillerController;                                  // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillingBlowHealthDelta;                            // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxTelemetryManager_OnPlayerDeath) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnPlayerDeath");
static_assert(sizeof(PhxTelemetryManager_OnPlayerDeath) == 0x000020, "Wrong size on PhxTelemetryManager_OnPlayerDeath");
static_assert(offsetof(PhxTelemetryManager_OnPlayerDeath, DeadCharacter) == 0x000000, "Member 'PhxTelemetryManager_OnPlayerDeath::DeadCharacter' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPlayerDeath, KillerActor) == 0x000008, "Member 'PhxTelemetryManager_OnPlayerDeath::KillerActor' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPlayerDeath, KillerController) == 0x000010, "Member 'PhxTelemetryManager_OnPlayerDeath::KillerController' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPlayerDeath, KillingBlowHealthDelta) == 0x000018, "Member 'PhxTelemetryManager_OnPlayerDeath::KillingBlowHealthDelta' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnPrinterInteract
// 0x0008 (0x0008 - 0x0000)
struct PhxTelemetryManager_OnPrinterInteract final
{
public:
	class AActor*                                 PrinterActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnPrinterInteract) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnPrinterInteract");
static_assert(sizeof(PhxTelemetryManager_OnPrinterInteract) == 0x000008, "Wrong size on PhxTelemetryManager_OnPrinterInteract");
static_assert(offsetof(PhxTelemetryManager_OnPrinterInteract, PrinterActor) == 0x000000, "Member 'PhxTelemetryManager_OnPrinterInteract::PrinterActor' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnPrinterPrinted
// 0x0028 (0x0028 - 0x0000)
struct PhxTelemetryManager_OnPrinterPrinted final
{
public:
	class AActor*                                 PrinterActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ItemName;                                          // 0x0008(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         QuantityPerItem;                                   // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         TotalQuantity;                                     // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ItemStacks;                                        // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         CostPerItem;                                       // 0x001C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         TotalCost;                                         // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxTelemetryManager_OnPrinterPrinted) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnPrinterPrinted");
static_assert(sizeof(PhxTelemetryManager_OnPrinterPrinted) == 0x000028, "Wrong size on PhxTelemetryManager_OnPrinterPrinted");
static_assert(offsetof(PhxTelemetryManager_OnPrinterPrinted, PrinterActor) == 0x000000, "Member 'PhxTelemetryManager_OnPrinterPrinted::PrinterActor' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPrinterPrinted, ItemName) == 0x000008, "Member 'PhxTelemetryManager_OnPrinterPrinted::ItemName' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPrinterPrinted, QuantityPerItem) == 0x000010, "Member 'PhxTelemetryManager_OnPrinterPrinted::QuantityPerItem' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPrinterPrinted, TotalQuantity) == 0x000014, "Member 'PhxTelemetryManager_OnPrinterPrinted::TotalQuantity' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPrinterPrinted, ItemStacks) == 0x000018, "Member 'PhxTelemetryManager_OnPrinterPrinted::ItemStacks' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPrinterPrinted, CostPerItem) == 0x00001C, "Member 'PhxTelemetryManager_OnPrinterPrinted::CostPerItem' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPrinterPrinted, TotalCost) == 0x000020, "Member 'PhxTelemetryManager_OnPrinterPrinted::TotalCost' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnPrinterUpgraded
// 0x0028 (0x0028 - 0x0000)
struct PhxTelemetryManager_OnPrinterUpgraded final
{
public:
	class AActor*                                 PrinterActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ItemName;                                          // 0x0008(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FText                                   RecipeName;                                        // 0x0010(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnPrinterUpgraded) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnPrinterUpgraded");
static_assert(sizeof(PhxTelemetryManager_OnPrinterUpgraded) == 0x000028, "Wrong size on PhxTelemetryManager_OnPrinterUpgraded");
static_assert(offsetof(PhxTelemetryManager_OnPrinterUpgraded, PrinterActor) == 0x000000, "Member 'PhxTelemetryManager_OnPrinterUpgraded::PrinterActor' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPrinterUpgraded, ItemName) == 0x000008, "Member 'PhxTelemetryManager_OnPrinterUpgraded::ItemName' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnPrinterUpgraded, RecipeName) == 0x000010, "Member 'PhxTelemetryManager_OnPrinterUpgraded::RecipeName' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnProductInStoreClosed
// 0x0018 (0x0018 - 0x0000)
struct PhxTelemetryManager_OnProductInStoreClosed final
{
public:
	class FString                                 ProductId;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bPurchased;                                        // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxTelemetryManager_OnProductInStoreClosed) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnProductInStoreClosed");
static_assert(sizeof(PhxTelemetryManager_OnProductInStoreClosed) == 0x000018, "Wrong size on PhxTelemetryManager_OnProductInStoreClosed");
static_assert(offsetof(PhxTelemetryManager_OnProductInStoreClosed, ProductId) == 0x000000, "Member 'PhxTelemetryManager_OnProductInStoreClosed::ProductId' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnProductInStoreClosed, bPurchased) == 0x000010, "Member 'PhxTelemetryManager_OnProductInStoreClosed::bPurchased' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnProductInStoreOpened
// 0x0010 (0x0010 - 0x0000)
struct PhxTelemetryManager_OnProductInStoreOpened final
{
public:
	class FString                                 ProductId;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnProductInStoreOpened) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnProductInStoreOpened");
static_assert(sizeof(PhxTelemetryManager_OnProductInStoreOpened) == 0x000010, "Wrong size on PhxTelemetryManager_OnProductInStoreOpened");
static_assert(offsetof(PhxTelemetryManager_OnProductInStoreOpened, ProductId) == 0x000000, "Member 'PhxTelemetryManager_OnProductInStoreOpened::ProductId' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnRangeAttack
// 0x0018 (0x0018 - 0x0000)
struct PhxTelemetryManager_OnRangeAttack final
{
public:
	const class APhxProjectile*                   Projectile;                                        // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class APhxCharacter*                    SourceCharacter;                                   // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class APhxCharacter*                    TargetCharacter;                                   // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnRangeAttack) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnRangeAttack");
static_assert(sizeof(PhxTelemetryManager_OnRangeAttack) == 0x000018, "Wrong size on PhxTelemetryManager_OnRangeAttack");
static_assert(offsetof(PhxTelemetryManager_OnRangeAttack, Projectile) == 0x000000, "Member 'PhxTelemetryManager_OnRangeAttack::Projectile' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnRangeAttack, SourceCharacter) == 0x000008, "Member 'PhxTelemetryManager_OnRangeAttack::SourceCharacter' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnRangeAttack, TargetCharacter) == 0x000010, "Member 'PhxTelemetryManager_OnRangeAttack::TargetCharacter' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnReceiverSwapped
// 0x0018 (0x0018 - 0x0000)
struct PhxTelemetryManager_OnReceiverSwapped final
{
public:
	class APhxCharacter*                          Character;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxRangedWeapon*                       PreviousWeapon;                                    // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxRangedWeapon*                       NewWeapon;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnReceiverSwapped) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnReceiverSwapped");
static_assert(sizeof(PhxTelemetryManager_OnReceiverSwapped) == 0x000018, "Wrong size on PhxTelemetryManager_OnReceiverSwapped");
static_assert(offsetof(PhxTelemetryManager_OnReceiverSwapped, Character) == 0x000000, "Member 'PhxTelemetryManager_OnReceiverSwapped::Character' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnReceiverSwapped, PreviousWeapon) == 0x000008, "Member 'PhxTelemetryManager_OnReceiverSwapped::PreviousWeapon' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnReceiverSwapped, NewWeapon) == 0x000010, "Member 'PhxTelemetryManager_OnReceiverSwapped::NewWeapon' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnRiotModeEnded
// 0x0014 (0x0014 - 0x0000)
struct PhxTelemetryManager_OnRiotModeEnded final
{
public:
	int32                                         NumberOfWavesSurvived;                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         TotalScore;                                        // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         TotalKills;                                        // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         TotalDismemberments;                               // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimeAlive;                                         // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnRiotModeEnded) == 0x000004, "Wrong alignment on PhxTelemetryManager_OnRiotModeEnded");
static_assert(sizeof(PhxTelemetryManager_OnRiotModeEnded) == 0x000014, "Wrong size on PhxTelemetryManager_OnRiotModeEnded");
static_assert(offsetof(PhxTelemetryManager_OnRiotModeEnded, NumberOfWavesSurvived) == 0x000000, "Member 'PhxTelemetryManager_OnRiotModeEnded::NumberOfWavesSurvived' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnRiotModeEnded, TotalScore) == 0x000004, "Member 'PhxTelemetryManager_OnRiotModeEnded::TotalScore' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnRiotModeEnded, TotalKills) == 0x000008, "Member 'PhxTelemetryManager_OnRiotModeEnded::TotalKills' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnRiotModeEnded, TotalDismemberments) == 0x00000C, "Member 'PhxTelemetryManager_OnRiotModeEnded::TotalDismemberments' has a wrong offset!");
static_assert(offsetof(PhxTelemetryManager_OnRiotModeEnded, TimeAlive) == 0x000010, "Member 'PhxTelemetryManager_OnRiotModeEnded::TimeAlive' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnRiotModeEndedTelemetry
// 0x0080 (0x0080 - 0x0000)
struct PhxTelemetryManager_OnRiotModeEndedTelemetry final
{
public:
	struct FPhxTelemetryRiotMode_GeneralData      GeneralTelemetry;                                  // 0x0000(0x0080)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnRiotModeEndedTelemetry) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnRiotModeEndedTelemetry");
static_assert(sizeof(PhxTelemetryManager_OnRiotModeEndedTelemetry) == 0x000080, "Wrong size on PhxTelemetryManager_OnRiotModeEndedTelemetry");
static_assert(offsetof(PhxTelemetryManager_OnRiotModeEndedTelemetry, GeneralTelemetry) == 0x000000, "Member 'PhxTelemetryManager_OnRiotModeEndedTelemetry::GeneralTelemetry' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnRiotModeItemPurchased
// 0x0020 (0x0020 - 0x0000)
struct PhxTelemetryManager_OnRiotModeItemPurchased final
{
public:
	struct FPhxTelemetryRiotMode_ItemPurchaseData ItemPurchasedTelemetry;                            // 0x0000(0x0020)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnRiotModeItemPurchased) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnRiotModeItemPurchased");
static_assert(sizeof(PhxTelemetryManager_OnRiotModeItemPurchased) == 0x000020, "Wrong size on PhxTelemetryManager_OnRiotModeItemPurchased");
static_assert(offsetof(PhxTelemetryManager_OnRiotModeItemPurchased, ItemPurchasedTelemetry) == 0x000000, "Member 'PhxTelemetryManager_OnRiotModeItemPurchased::ItemPurchasedTelemetry' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnRiotModePassivePerksSet
// 0x0018 (0x0018 - 0x0000)
struct PhxTelemetryManager_OnRiotModePassivePerksSet final
{
public:
	struct FPhxTelemetryRiotMode_PassivePerksData PassivePerksTelemetry;                             // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnRiotModePassivePerksSet) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnRiotModePassivePerksSet");
static_assert(sizeof(PhxTelemetryManager_OnRiotModePassivePerksSet) == 0x000018, "Wrong size on PhxTelemetryManager_OnRiotModePassivePerksSet");
static_assert(offsetof(PhxTelemetryManager_OnRiotModePassivePerksSet, PassivePerksTelemetry) == 0x000000, "Member 'PhxTelemetryManager_OnRiotModePassivePerksSet::PassivePerksTelemetry' has a wrong offset!");

// Function Phoenix.PhxTelemetryManager.OnRiotModeWaveCompleted
// 0x0018 (0x0018 - 0x0000)
struct PhxTelemetryManager_OnRiotModeWaveCompleted final
{
public:
	struct FPhxTelemetryRiotMode_WaveCompletedData WaveCompletedTelemetry;                           // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTelemetryManager_OnRiotModeWaveCompleted) == 0x000008, "Wrong alignment on PhxTelemetryManager_OnRiotModeWaveCompleted");
static_assert(sizeof(PhxTelemetryManager_OnRiotModeWaveCompleted) == 0x000018, "Wrong size on PhxTelemetryManager_OnRiotModeWaveCompleted");
static_assert(offsetof(PhxTelemetryManager_OnRiotModeWaveCompleted, WaveCompletedTelemetry) == 0x000000, "Member 'PhxTelemetryManager_OnRiotModeWaveCompleted::WaveCompletedTelemetry' has a wrong offset!");

// Function Phoenix.PhxTetherSplineComponent.AttachEndPointTo
// 0x0008 (0x0008 - 0x0000)
struct PhxTetherSplineComponent_AttachEndPointTo final
{
public:
	class USceneComponent*                        Component;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTetherSplineComponent_AttachEndPointTo) == 0x000008, "Wrong alignment on PhxTetherSplineComponent_AttachEndPointTo");
static_assert(sizeof(PhxTetherSplineComponent_AttachEndPointTo) == 0x000008, "Wrong size on PhxTetherSplineComponent_AttachEndPointTo");
static_assert(offsetof(PhxTetherSplineComponent_AttachEndPointTo, Component) == 0x000000, "Member 'PhxTetherSplineComponent_AttachEndPointTo::Component' has a wrong offset!");

// Function Phoenix.PhxTetherSplineComponent.GetEndPointTransform
// 0x0030 (0x0030 - 0x0000)
struct PhxTetherSplineComponent_GetEndPointTransform final
{
public:
	struct FTransform                             ReturnValue;                                       // 0x0000(0x0030)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTetherSplineComponent_GetEndPointTransform) == 0x000010, "Wrong alignment on PhxTetherSplineComponent_GetEndPointTransform");
static_assert(sizeof(PhxTetherSplineComponent_GetEndPointTransform) == 0x000030, "Wrong size on PhxTetherSplineComponent_GetEndPointTransform");
static_assert(offsetof(PhxTetherSplineComponent_GetEndPointTransform, ReturnValue) == 0x000000, "Member 'PhxTetherSplineComponent_GetEndPointTransform::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxTetherSplineComponent.ReleaseEndPoint
// 0x0001 (0x0001 - 0x0000)
struct PhxTetherSplineComponent_ReleaseEndPoint final
{
public:
	bool                                          bClearSplinePoints;                                // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTetherSplineComponent_ReleaseEndPoint) == 0x000001, "Wrong alignment on PhxTetherSplineComponent_ReleaseEndPoint");
static_assert(sizeof(PhxTetherSplineComponent_ReleaseEndPoint) == 0x000001, "Wrong size on PhxTetherSplineComponent_ReleaseEndPoint");
static_assert(offsetof(PhxTetherSplineComponent_ReleaseEndPoint, bClearSplinePoints) == 0x000000, "Member 'PhxTetherSplineComponent_ReleaseEndPoint::bClearSplinePoints' has a wrong offset!");

// Function Phoenix.PhxTetherSplineComponent.GetDesiredEndPointLocation
// 0x000C (0x000C - 0x0000)
struct PhxTetherSplineComponent_GetDesiredEndPointLocation final
{
public:
	struct FVector                                ReturnValue;                                       // 0x0000(0x000C)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTetherSplineComponent_GetDesiredEndPointLocation) == 0x000004, "Wrong alignment on PhxTetherSplineComponent_GetDesiredEndPointLocation");
static_assert(sizeof(PhxTetherSplineComponent_GetDesiredEndPointLocation) == 0x00000C, "Wrong size on PhxTetherSplineComponent_GetDesiredEndPointLocation");
static_assert(offsetof(PhxTetherSplineComponent_GetDesiredEndPointLocation, ReturnValue) == 0x000000, "Member 'PhxTetherSplineComponent_GetDesiredEndPointLocation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxTetherSplineComponent.GetEndPointAttachComponent
// 0x0008 (0x0008 - 0x0000)
struct PhxTetherSplineComponent_GetEndPointAttachComponent final
{
public:
	class USceneComponent*                        ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTetherSplineComponent_GetEndPointAttachComponent) == 0x000008, "Wrong alignment on PhxTetherSplineComponent_GetEndPointAttachComponent");
static_assert(sizeof(PhxTetherSplineComponent_GetEndPointAttachComponent) == 0x000008, "Wrong size on PhxTetherSplineComponent_GetEndPointAttachComponent");
static_assert(offsetof(PhxTetherSplineComponent_GetEndPointAttachComponent, ReturnValue) == 0x000000, "Member 'PhxTetherSplineComponent_GetEndPointAttachComponent::ReturnValue' has a wrong offset!");

// Function Phoenix.PigSpline.SetNextSpline
// 0x0008 (0x0008 - 0x0000)
struct PigSpline_SetNextSpline final
{
public:
	TSubclassOf<class APigSpline>                 Next;                                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PigSpline_SetNextSpline) == 0x000008, "Wrong alignment on PigSpline_SetNextSpline");
static_assert(sizeof(PigSpline_SetNextSpline) == 0x000008, "Wrong size on PigSpline_SetNextSpline");
static_assert(offsetof(PigSpline_SetNextSpline, Next) == 0x000000, "Member 'PigSpline_SetNextSpline::Next' has a wrong offset!");

// Function Phoenix.PhxTraversalVolumeComponent.IsTraversalTypeAllowed
// 0x0002 (0x0002 - 0x0000)
struct PhxTraversalVolumeComponent_IsTraversalTypeAllowed final
{
public:
	EVolumeTraversalType                          TraversalType;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0001(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTraversalVolumeComponent_IsTraversalTypeAllowed) == 0x000001, "Wrong alignment on PhxTraversalVolumeComponent_IsTraversalTypeAllowed");
static_assert(sizeof(PhxTraversalVolumeComponent_IsTraversalTypeAllowed) == 0x000002, "Wrong size on PhxTraversalVolumeComponent_IsTraversalTypeAllowed");
static_assert(offsetof(PhxTraversalVolumeComponent_IsTraversalTypeAllowed, TraversalType) == 0x000000, "Member 'PhxTraversalVolumeComponent_IsTraversalTypeAllowed::TraversalType' has a wrong offset!");
static_assert(offsetof(PhxTraversalVolumeComponent_IsTraversalTypeAllowed, ReturnValue) == 0x000001, "Member 'PhxTraversalVolumeComponent_IsTraversalTypeAllowed::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxTraversalVolumeComponent.SetAllowedTraversalTypes
// 0x0001 (0x0001 - 0x0000)
struct PhxTraversalVolumeComponent_SetAllowedTraversalTypes final
{
public:
	uint8                                         VolumeTraversalTypes;                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTraversalVolumeComponent_SetAllowedTraversalTypes) == 0x000001, "Wrong alignment on PhxTraversalVolumeComponent_SetAllowedTraversalTypes");
static_assert(sizeof(PhxTraversalVolumeComponent_SetAllowedTraversalTypes) == 0x000001, "Wrong size on PhxTraversalVolumeComponent_SetAllowedTraversalTypes");
static_assert(offsetof(PhxTraversalVolumeComponent_SetAllowedTraversalTypes, VolumeTraversalTypes) == 0x000000, "Member 'PhxTraversalVolumeComponent_SetAllowedTraversalTypes::VolumeTraversalTypes' has a wrong offset!");

// Function Phoenix.PhxTraversalVolumeComponent.GetTraversalHeight
// 0x0008 (0x0008 - 0x0000)
struct PhxTraversalVolumeComponent_GetTraversalHeight final
{
public:
	float                                         PlayerZ;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0004(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTraversalVolumeComponent_GetTraversalHeight) == 0x000004, "Wrong alignment on PhxTraversalVolumeComponent_GetTraversalHeight");
static_assert(sizeof(PhxTraversalVolumeComponent_GetTraversalHeight) == 0x000008, "Wrong size on PhxTraversalVolumeComponent_GetTraversalHeight");
static_assert(offsetof(PhxTraversalVolumeComponent_GetTraversalHeight, PlayerZ) == 0x000000, "Member 'PhxTraversalVolumeComponent_GetTraversalHeight::PlayerZ' has a wrong offset!");
static_assert(offsetof(PhxTraversalVolumeComponent_GetTraversalHeight, ReturnValue) == 0x000004, "Member 'PhxTraversalVolumeComponent_GetTraversalHeight::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxTutorialHintUI.Setup
// 0x0040 (0x0040 - 0x0000)
struct PhxTutorialHintUI_Setup final
{
public:
	struct FTutorialHintRequest                   InRequest;                                         // 0x0000(0x0040)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxTutorialHintUI_Setup) == 0x000008, "Wrong alignment on PhxTutorialHintUI_Setup");
static_assert(sizeof(PhxTutorialHintUI_Setup) == 0x000040, "Wrong size on PhxTutorialHintUI_Setup");
static_assert(offsetof(PhxTutorialHintUI_Setup, InRequest) == 0x000000, "Member 'PhxTutorialHintUI_Setup::InRequest' has a wrong offset!");

// Function Phoenix.PhxUpgradeComponent.ApplyUpgrade
// 0x0008 (0x0008 - 0x0000)
struct PhxUpgradeComponent_ApplyUpgrade final
{
public:
	const class UPhxWeaponModificationRecipe*     UpgradeRecipe;                                     // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxUpgradeComponent_ApplyUpgrade) == 0x000008, "Wrong alignment on PhxUpgradeComponent_ApplyUpgrade");
static_assert(sizeof(PhxUpgradeComponent_ApplyUpgrade) == 0x000008, "Wrong size on PhxUpgradeComponent_ApplyUpgrade");
static_assert(offsetof(PhxUpgradeComponent_ApplyUpgrade, UpgradeRecipe) == 0x000000, "Member 'PhxUpgradeComponent_ApplyUpgrade::UpgradeRecipe' has a wrong offset!");

// Function Phoenix.PhxUpgradeComponent.RemoveUpgrade
// 0x0008 (0x0008 - 0x0000)
struct PhxUpgradeComponent_RemoveUpgrade final
{
public:
	const class UPhxWeaponModificationRecipe*     UpgradeRecipe;                                     // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxUpgradeComponent_RemoveUpgrade) == 0x000008, "Wrong alignment on PhxUpgradeComponent_RemoveUpgrade");
static_assert(sizeof(PhxUpgradeComponent_RemoveUpgrade) == 0x000008, "Wrong size on PhxUpgradeComponent_RemoveUpgrade");
static_assert(offsetof(PhxUpgradeComponent_RemoveUpgrade, UpgradeRecipe) == 0x000000, "Member 'PhxUpgradeComponent_RemoveUpgrade::UpgradeRecipe' has a wrong offset!");

// Function Phoenix.PhxUpgradeComponent.IsRecipeApplied
// 0x0010 (0x0010 - 0x0000)
struct PhxUpgradeComponent_IsRecipeApplied final
{
public:
	const class UPhxWeaponModificationRecipe*     UpgradeRecipe;                                     // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxUpgradeComponent_IsRecipeApplied) == 0x000008, "Wrong alignment on PhxUpgradeComponent_IsRecipeApplied");
static_assert(sizeof(PhxUpgradeComponent_IsRecipeApplied) == 0x000010, "Wrong size on PhxUpgradeComponent_IsRecipeApplied");
static_assert(offsetof(PhxUpgradeComponent_IsRecipeApplied, UpgradeRecipe) == 0x000000, "Member 'PhxUpgradeComponent_IsRecipeApplied::UpgradeRecipe' has a wrong offset!");
static_assert(offsetof(PhxUpgradeComponent_IsRecipeApplied, ReturnValue) == 0x000008, "Member 'PhxUpgradeComponent_IsRecipeApplied::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxVehicle.RequestSplineFollow
// 0x0010 (0x0010 - 0x0000)
struct PhxVehicle_RequestSplineFollow final
{
public:
	struct FVehSplineFollowParams                 FollowParams;                                      // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxVehicle_RequestSplineFollow) == 0x000008, "Wrong alignment on PhxVehicle_RequestSplineFollow");
static_assert(sizeof(PhxVehicle_RequestSplineFollow) == 0x000010, "Wrong size on PhxVehicle_RequestSplineFollow");
static_assert(offsetof(PhxVehicle_RequestSplineFollow, FollowParams) == 0x000000, "Member 'PhxVehicle_RequestSplineFollow::FollowParams' has a wrong offset!");

// Function Phoenix.PhxViewTrigger.HandleComponentBeginOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PhxViewTrigger_HandleComponentBeginOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxViewTrigger_HandleComponentBeginOverlap) == 0x000008, "Wrong alignment on PhxViewTrigger_HandleComponentBeginOverlap");
static_assert(sizeof(PhxViewTrigger_HandleComponentBeginOverlap) == 0x0000A8, "Wrong size on PhxViewTrigger_HandleComponentBeginOverlap");
static_assert(offsetof(PhxViewTrigger_HandleComponentBeginOverlap, OverlappedComponent) == 0x000000, "Member 'PhxViewTrigger_HandleComponentBeginOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleComponentBeginOverlap, OtherActor) == 0x000008, "Member 'PhxViewTrigger_HandleComponentBeginOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleComponentBeginOverlap, OtherComp) == 0x000010, "Member 'PhxViewTrigger_HandleComponentBeginOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleComponentBeginOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxViewTrigger_HandleComponentBeginOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleComponentBeginOverlap, bFromSweep) == 0x00001C, "Member 'PhxViewTrigger_HandleComponentBeginOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleComponentBeginOverlap, SweepResult) == 0x000020, "Member 'PhxViewTrigger_HandleComponentBeginOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PhxViewTrigger.HandleComponentEndOverlap
// 0x0020 (0x0020 - 0x0000)
struct PhxViewTrigger_HandleComponentEndOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxViewTrigger_HandleComponentEndOverlap) == 0x000008, "Wrong alignment on PhxViewTrigger_HandleComponentEndOverlap");
static_assert(sizeof(PhxViewTrigger_HandleComponentEndOverlap) == 0x000020, "Wrong size on PhxViewTrigger_HandleComponentEndOverlap");
static_assert(offsetof(PhxViewTrigger_HandleComponentEndOverlap, OverlappedComponent) == 0x000000, "Member 'PhxViewTrigger_HandleComponentEndOverlap::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleComponentEndOverlap, OtherActor) == 0x000008, "Member 'PhxViewTrigger_HandleComponentEndOverlap::OtherActor' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleComponentEndOverlap, OtherComp) == 0x000010, "Member 'PhxViewTrigger_HandleComponentEndOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleComponentEndOverlap, OtherBodyIndex) == 0x000018, "Member 'PhxViewTrigger_HandleComponentEndOverlap::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PhxViewTrigger.HandleOverlappingPlayerFocusTargetChanged
// 0x0018 (0x0018 - 0x0000)
struct PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged final
{
public:
	class APhxPlayerCharacter*                    Player;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 PreviousFocusTarget;                               // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 NewFocusTarget;                                    // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged) == 0x000008, "Wrong alignment on PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged");
static_assert(sizeof(PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged) == 0x000018, "Wrong size on PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged");
static_assert(offsetof(PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged, Player) == 0x000000, "Member 'PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged::Player' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged, PreviousFocusTarget) == 0x000008, "Member 'PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged::PreviousFocusTarget' has a wrong offset!");
static_assert(offsetof(PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged, NewFocusTarget) == 0x000010, "Member 'PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged::NewFocusTarget' has a wrong offset!");

// Function Phoenix.PhxViewTrigger.SetTriggerEnabled
// 0x0001 (0x0001 - 0x0000)
struct PhxViewTrigger_SetTriggerEnabled final
{
public:
	bool                                          bEnableTrigger;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxViewTrigger_SetTriggerEnabled) == 0x000001, "Wrong alignment on PhxViewTrigger_SetTriggerEnabled");
static_assert(sizeof(PhxViewTrigger_SetTriggerEnabled) == 0x000001, "Wrong size on PhxViewTrigger_SetTriggerEnabled");
static_assert(offsetof(PhxViewTrigger_SetTriggerEnabled, bEnableTrigger) == 0x000000, "Member 'PhxViewTrigger_SetTriggerEnabled::bEnableTrigger' has a wrong offset!");

// Function Phoenix.PhxViewTrigger.SetViewTargetActor
// 0x0008 (0x0008 - 0x0000)
struct PhxViewTrigger_SetViewTargetActor final
{
public:
	const class AActor*                           TargetActor;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxViewTrigger_SetViewTargetActor) == 0x000008, "Wrong alignment on PhxViewTrigger_SetViewTargetActor");
static_assert(sizeof(PhxViewTrigger_SetViewTargetActor) == 0x000008, "Wrong size on PhxViewTrigger_SetViewTargetActor");
static_assert(offsetof(PhxViewTrigger_SetViewTargetActor, TargetActor) == 0x000000, "Member 'PhxViewTrigger_SetViewTargetActor::TargetActor' has a wrong offset!");

// Function Phoenix.PhxWaitForAsyncLoadComplete.CreateTeleportCharacterAndWaitForStreaming
// 0x0050 (0x0050 - 0x0000)
struct PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxCharacter*                          Character;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FTransform                             Transform;                                         // 0x0010(0x0030)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         TimerInterval_0;                                   // 0x0040(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxWaitForAsyncLoadComplete*           ReturnValue;                                       // 0x0048(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming) == 0x000010, "Wrong alignment on PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming");
static_assert(sizeof(PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming) == 0x000050, "Wrong size on PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming");
static_assert(offsetof(PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming, WorldContextObject) == 0x000000, "Member 'PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming, Character) == 0x000008, "Member 'PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming::Character' has a wrong offset!");
static_assert(offsetof(PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming, Transform) == 0x000010, "Member 'PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming::Transform' has a wrong offset!");
static_assert(offsetof(PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming, TimerInterval_0) == 0x000040, "Member 'PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming::TimerInterval_0' has a wrong offset!");
static_assert(offsetof(PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming, ReturnValue) == 0x000048, "Member 'PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWaitForAsyncLoadComplete.CreateWaitForAsyncLoadComplete
// 0x0018 (0x0018 - 0x0000)
struct PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimerInterval_0;                                   // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxWaitForAsyncLoadComplete*           ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete) == 0x000008, "Wrong alignment on PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete");
static_assert(sizeof(PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete) == 0x000018, "Wrong size on PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete");
static_assert(offsetof(PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete, WorldContextObject) == 0x000000, "Member 'PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete, TimerInterval_0) == 0x000008, "Member 'PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete::TimerInterval_0' has a wrong offset!");
static_assert(offsetof(PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete, ReturnValue) == 0x000010, "Member 'PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWeakSpotComponent_Virus.OnOwnerTakeAnyDamage
// 0x0028 (0x0028 - 0x0000)
struct PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	const class UDamageType*                      DamageType;                                        // 0x0010(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0020(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage) == 0x000008, "Wrong alignment on PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage");
static_assert(sizeof(PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage) == 0x000028, "Wrong size on PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage, DamagedActor) == 0x000000, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage, Damage) == 0x000008, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage, DamageType) == 0x000010, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage::DamageType' has a wrong offset!");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage, InstigatedBy) == 0x000018, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage, DamageCauser) == 0x000020, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxWeakSpotComponent_Virus.OnOwnerTakeMeleeDamage
// 0x0110 (0x0110 - 0x0000)
struct PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage final
{
public:
	class AActor*                                 DamagedActor;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPhxMeleeDamageEvent                   MeleeDamageEvent;                                  // 0x0010(0x00F0)(ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
	class AController*                            InstigatedBy;                                      // 0x0100(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 DamageCauser;                                      // 0x0108(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage) == 0x000008, "Wrong alignment on PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage");
static_assert(sizeof(PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage) == 0x000110, "Wrong size on PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage, DamagedActor) == 0x000000, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage::DamagedActor' has a wrong offset!");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage, Damage) == 0x000008, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage::Damage' has a wrong offset!");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage, MeleeDamageEvent) == 0x000010, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage::MeleeDamageEvent' has a wrong offset!");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage, InstigatedBy) == 0x000100, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage::InstigatedBy' has a wrong offset!");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage, DamageCauser) == 0x000108, "Member 'PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage::DamageCauser' has a wrong offset!");

// Function Phoenix.PhxWeakSpotComponent_Virus.OnVirusAimingChanged
// 0x0010 (0x0010 - 0x0000)
struct PhxWeakSpotComponent_Virus_OnVirusAimingChanged final
{
public:
	class APhxCharacter*                          AimingCharacter;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bOn;                                               // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PhxWeakSpotComponent_Virus_OnVirusAimingChanged) == 0x000008, "Wrong alignment on PhxWeakSpotComponent_Virus_OnVirusAimingChanged");
static_assert(sizeof(PhxWeakSpotComponent_Virus_OnVirusAimingChanged) == 0x000010, "Wrong size on PhxWeakSpotComponent_Virus_OnVirusAimingChanged");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnVirusAimingChanged, AimingCharacter) == 0x000000, "Member 'PhxWeakSpotComponent_Virus_OnVirusAimingChanged::AimingCharacter' has a wrong offset!");
static_assert(offsetof(PhxWeakSpotComponent_Virus_OnVirusAimingChanged, bOn) == 0x000008, "Member 'PhxWeakSpotComponent_Virus_OnVirusAimingChanged::bOn' has a wrong offset!");

// Function Phoenix.PhxWeakSpotComponent_Virus.SpawnVirus
// 0x0001 (0x0001 - 0x0000)
struct PhxWeakSpotComponent_Virus_SpawnVirus final
{
public:
	bool                                          bQuickMutate;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeakSpotComponent_Virus_SpawnVirus) == 0x000001, "Wrong alignment on PhxWeakSpotComponent_Virus_SpawnVirus");
static_assert(sizeof(PhxWeakSpotComponent_Virus_SpawnVirus) == 0x000001, "Wrong size on PhxWeakSpotComponent_Virus_SpawnVirus");
static_assert(offsetof(PhxWeakSpotComponent_Virus_SpawnVirus, bQuickMutate) == 0x000000, "Member 'PhxWeakSpotComponent_Virus_SpawnVirus::bQuickMutate' has a wrong offset!");

// Function Phoenix.PhxWeaponSchematic.IsDataUploadedToPrinter
// 0x0001 (0x0001 - 0x0000)
struct PhxWeaponSchematic_IsDataUploadedToPrinter final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWeaponSchematic_IsDataUploadedToPrinter) == 0x000001, "Wrong alignment on PhxWeaponSchematic_IsDataUploadedToPrinter");
static_assert(sizeof(PhxWeaponSchematic_IsDataUploadedToPrinter) == 0x000001, "Wrong size on PhxWeaponSchematic_IsDataUploadedToPrinter");
static_assert(offsetof(PhxWeaponSchematic_IsDataUploadedToPrinter, ReturnValue) == 0x000000, "Member 'PhxWeaponSchematic_IsDataUploadedToPrinter::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldSettings.GetPhxWorldSettings
// 0x0010 (0x0010 - 0x0000)
struct PhxWorldSettings_GetPhxWorldSettings final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhxWorldSettings*                      ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldSettings_GetPhxWorldSettings) == 0x000008, "Wrong alignment on PhxWorldSettings_GetPhxWorldSettings");
static_assert(sizeof(PhxWorldSettings_GetPhxWorldSettings) == 0x000010, "Wrong size on PhxWorldSettings_GetPhxWorldSettings");
static_assert(offsetof(PhxWorldSettings_GetPhxWorldSettings, WorldContextObject) == 0x000000, "Member 'PhxWorldSettings_GetPhxWorldSettings::WorldContextObject' has a wrong offset!");
static_assert(offsetof(PhxWorldSettings_GetPhxWorldSettings, ReturnValue) == 0x000008, "Member 'PhxWorldSettings_GetPhxWorldSettings::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldSettings.GetLevelTags
// 0x0020 (0x0020 - 0x0000)
struct PhxWorldSettings_GetLevelTags final
{
public:
	struct FGameplayTagContainer                  ReturnValue;                                       // 0x0000(0x0020)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldSettings_GetLevelTags) == 0x000008, "Wrong alignment on PhxWorldSettings_GetLevelTags");
static_assert(sizeof(PhxWorldSettings_GetLevelTags) == 0x000020, "Wrong size on PhxWorldSettings_GetLevelTags");
static_assert(offsetof(PhxWorldSettings_GetLevelTags, ReturnValue) == 0x000000, "Member 'PhxWorldSettings_GetLevelTags::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWorldSettings.GetTimeDilation
// 0x0004 (0x0004 - 0x0000)
struct PhxWorldSettings_GetTimeDilation final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWorldSettings_GetTimeDilation) == 0x000004, "Wrong alignment on PhxWorldSettings_GetTimeDilation");
static_assert(sizeof(PhxWorldSettings_GetTimeDilation) == 0x000004, "Wrong size on PhxWorldSettings_GetTimeDilation");
static_assert(offsetof(PhxWorldSettings_GetTimeDilation, ReturnValue) == 0x000000, "Member 'PhxWorldSettings_GetTimeDilation::ReturnValue' has a wrong offset!");

// Function Phoenix.PhxWoundManager.OnTexturesLoaded
// 0x0018 (0x0018 - 0x0000)
struct PhxWoundManager_OnTexturesLoaded final
{
public:
	bool                                          bLoadedSuccessfully;                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UPhxWound*>                      LoadedWounds;                                      // 0x0008(0x0010)(Parm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(PhxWoundManager_OnTexturesLoaded) == 0x000008, "Wrong alignment on PhxWoundManager_OnTexturesLoaded");
static_assert(sizeof(PhxWoundManager_OnTexturesLoaded) == 0x000018, "Wrong size on PhxWoundManager_OnTexturesLoaded");
static_assert(offsetof(PhxWoundManager_OnTexturesLoaded, bLoadedSuccessfully) == 0x000000, "Member 'PhxWoundManager_OnTexturesLoaded::bLoadedSuccessfully' has a wrong offset!");
static_assert(offsetof(PhxWoundManager_OnTexturesLoaded, LoadedWounds) == 0x000008, "Member 'PhxWoundManager_OnTexturesLoaded::LoadedWounds' has a wrong offset!");

// Function Phoenix.PigPlatform.ActorHitByForce
// 0x00A8 (0x00A8 - 0x0000)
struct PigPlatform_ActorHitByForce final
{
public:
	class AActor*                                 ActorSelf;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Other;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                B;                                                 // 0x0010(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             Hit;                                               // 0x001C(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_A4[0x4];                                       // 0x00A4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PigPlatform_ActorHitByForce) == 0x000008, "Wrong alignment on PigPlatform_ActorHitByForce");
static_assert(sizeof(PigPlatform_ActorHitByForce) == 0x0000A8, "Wrong size on PigPlatform_ActorHitByForce");
static_assert(offsetof(PigPlatform_ActorHitByForce, ActorSelf) == 0x000000, "Member 'PigPlatform_ActorHitByForce::ActorSelf' has a wrong offset!");
static_assert(offsetof(PigPlatform_ActorHitByForce, Other) == 0x000008, "Member 'PigPlatform_ActorHitByForce::Other' has a wrong offset!");
static_assert(offsetof(PigPlatform_ActorHitByForce, B) == 0x000010, "Member 'PigPlatform_ActorHitByForce::B' has a wrong offset!");
static_assert(offsetof(PigPlatform_ActorHitByForce, Hit) == 0x00001C, "Member 'PigPlatform_ActorHitByForce::Hit' has a wrong offset!");

// Function Phoenix.PigPlatform.SetNextSpline
// 0x0008 (0x0008 - 0x0000)
struct PigPlatform_SetNextSpline final
{
public:
	TSubclassOf<class APigSpline>                 Next;                                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PigPlatform_SetNextSpline) == 0x000008, "Wrong alignment on PigPlatform_SetNextSpline");
static_assert(sizeof(PigPlatform_SetNextSpline) == 0x000008, "Wrong size on PigPlatform_SetNextSpline");
static_assert(offsetof(PigPlatform_SetNextSpline, Next) == 0x000000, "Member 'PigPlatform_SetNextSpline::Next' has a wrong offset!");

// Function Phoenix.PigPlatform.TriggerEndOverlap
// 0x0020 (0x0020 - 0x0000)
struct PigPlatform_TriggerEndOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComp;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Other;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PigPlatform_TriggerEndOverlap) == 0x000008, "Wrong alignment on PigPlatform_TriggerEndOverlap");
static_assert(sizeof(PigPlatform_TriggerEndOverlap) == 0x000020, "Wrong size on PigPlatform_TriggerEndOverlap");
static_assert(offsetof(PigPlatform_TriggerEndOverlap, OverlappedComp) == 0x000000, "Member 'PigPlatform_TriggerEndOverlap::OverlappedComp' has a wrong offset!");
static_assert(offsetof(PigPlatform_TriggerEndOverlap, Other) == 0x000008, "Member 'PigPlatform_TriggerEndOverlap::Other' has a wrong offset!");
static_assert(offsetof(PigPlatform_TriggerEndOverlap, OtherComp) == 0x000010, "Member 'PigPlatform_TriggerEndOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PigPlatform_TriggerEndOverlap, OtherBodyIndex) == 0x000018, "Member 'PigPlatform_TriggerEndOverlap::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PigPlatform.TriggerOverlap
// 0x00A8 (0x00A8 - 0x0000)
struct PigPlatform_TriggerOverlap final
{
public:
	class UPrimitiveComponent*                    OverlappedComp;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 Other;                                             // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PigPlatform_TriggerOverlap) == 0x000008, "Wrong alignment on PigPlatform_TriggerOverlap");
static_assert(sizeof(PigPlatform_TriggerOverlap) == 0x0000A8, "Wrong size on PigPlatform_TriggerOverlap");
static_assert(offsetof(PigPlatform_TriggerOverlap, OverlappedComp) == 0x000000, "Member 'PigPlatform_TriggerOverlap::OverlappedComp' has a wrong offset!");
static_assert(offsetof(PigPlatform_TriggerOverlap, Other) == 0x000008, "Member 'PigPlatform_TriggerOverlap::Other' has a wrong offset!");
static_assert(offsetof(PigPlatform_TriggerOverlap, OtherComp) == 0x000010, "Member 'PigPlatform_TriggerOverlap::OtherComp' has a wrong offset!");
static_assert(offsetof(PigPlatform_TriggerOverlap, OtherBodyIndex) == 0x000018, "Member 'PigPlatform_TriggerOverlap::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PigPlatform_TriggerOverlap, bFromSweep) == 0x00001C, "Member 'PigPlatform_TriggerOverlap::bFromSweep' has a wrong offset!");
static_assert(offsetof(PigPlatform_TriggerOverlap, SweepResult) == 0x000020, "Member 'PigPlatform_TriggerOverlap::SweepResult' has a wrong offset!");

// Function Phoenix.PlaceholderVOWidget.SetLine
// 0x0018 (0x0018 - 0x0000)
struct PlaceholderVOWidget_SetLine final
{
public:
	class FString                                 Line;                                              // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Duration;                                          // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PlaceholderVOWidget_SetLine) == 0x000008, "Wrong alignment on PlaceholderVOWidget_SetLine");
static_assert(sizeof(PlaceholderVOWidget_SetLine) == 0x000018, "Wrong size on PlaceholderVOWidget_SetLine");
static_assert(offsetof(PlaceholderVOWidget_SetLine, Line) == 0x000000, "Member 'PlaceholderVOWidget_SetLine::Line' has a wrong offset!");
static_assert(offsetof(PlaceholderVOWidget_SetLine, Duration) == 0x000010, "Member 'PlaceholderVOWidget_SetLine::Duration' has a wrong offset!");

// Function Phoenix.PPEChargeComponent.AddCharge
// 0x0004 (0x0004 - 0x0000)
struct PPEChargeComponent_AddCharge final
{
public:
	float                                         Amount;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEChargeComponent_AddCharge) == 0x000004, "Wrong alignment on PPEChargeComponent_AddCharge");
static_assert(sizeof(PPEChargeComponent_AddCharge) == 0x000004, "Wrong size on PPEChargeComponent_AddCharge");
static_assert(offsetof(PPEChargeComponent_AddCharge, Amount) == 0x000000, "Member 'PPEChargeComponent_AddCharge::Amount' has a wrong offset!");

// Function Phoenix.PPEChargeComponent.GetCharge
// 0x0004 (0x0004 - 0x0000)
struct PPEChargeComponent_GetCharge final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEChargeComponent_GetCharge) == 0x000004, "Wrong alignment on PPEChargeComponent_GetCharge");
static_assert(sizeof(PPEChargeComponent_GetCharge) == 0x000004, "Wrong size on PPEChargeComponent_GetCharge");
static_assert(offsetof(PPEChargeComponent_GetCharge, ReturnValue) == 0x000000, "Member 'PPEChargeComponent_GetCharge::ReturnValue' has a wrong offset!");

// Function Phoenix.PPEChargeComponent.GetMaxCharge
// 0x0004 (0x0004 - 0x0000)
struct PPEChargeComponent_GetMaxCharge final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PPEChargeComponent_GetMaxCharge) == 0x000004, "Wrong alignment on PPEChargeComponent_GetMaxCharge");
static_assert(sizeof(PPEChargeComponent_GetMaxCharge) == 0x000004, "Wrong size on PPEChargeComponent_GetMaxCharge");
static_assert(offsetof(PPEChargeComponent_GetMaxCharge, ReturnValue) == 0x000000, "Member 'PPEChargeComponent_GetMaxCharge::ReturnValue' has a wrong offset!");

// Function Phoenix.PrinterUploadElement.ApplyVID
// 0x0008 (0x0008 - 0x0000)
struct PrinterUploadElement_ApplyVID final
{
public:
	const class UVirtualItemData*                 InVID;                                             // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterUploadElement_ApplyVID) == 0x000008, "Wrong alignment on PrinterUploadElement_ApplyVID");
static_assert(sizeof(PrinterUploadElement_ApplyVID) == 0x000008, "Wrong size on PrinterUploadElement_ApplyVID");
static_assert(offsetof(PrinterUploadElement_ApplyVID, InVID) == 0x000000, "Member 'PrinterUploadElement_ApplyVID::InVID' has a wrong offset!");

// Function Phoenix.PrinterV2UpgradeState.CharacterNotify
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2UpgradeState_CharacterNotify final
{
public:
	const class UPhxAnimNotify*                   Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2UpgradeState_CharacterNotify) == 0x000008, "Wrong alignment on PrinterV2UpgradeState_CharacterNotify");
static_assert(sizeof(PrinterV2UpgradeState_CharacterNotify) == 0x000008, "Wrong size on PrinterV2UpgradeState_CharacterNotify");
static_assert(offsetof(PrinterV2UpgradeState_CharacterNotify, Notify) == 0x000000, "Member 'PrinterV2UpgradeState_CharacterNotify::Notify' has a wrong offset!");

// Function Phoenix.PrinterV2UpgradeState.PrinterNotify
// 0x0008 (0x0008 - 0x0000)
struct PrinterV2UpgradeState_PrinterNotify final
{
public:
	const class UPhxPrinterAnimNotify*            Notify;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterV2UpgradeState_PrinterNotify) == 0x000008, "Wrong alignment on PrinterV2UpgradeState_PrinterNotify");
static_assert(sizeof(PrinterV2UpgradeState_PrinterNotify) == 0x000008, "Wrong size on PrinterV2UpgradeState_PrinterNotify");
static_assert(offsetof(PrinterV2UpgradeState_PrinterNotify, Notify) == 0x000000, "Member 'PrinterV2UpgradeState_PrinterNotify::Notify' has a wrong offset!");

// Function Phoenix.PrinterWidget.ShowOutputMenu
// 0x0010 (0x0010 - 0x0000)
struct PrinterWidget_ShowOutputMenu final
{
public:
	class FName                                   ItemName;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture*                               OverlayPicture;                                    // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterWidget_ShowOutputMenu) == 0x000008, "Wrong alignment on PrinterWidget_ShowOutputMenu");
static_assert(sizeof(PrinterWidget_ShowOutputMenu) == 0x000010, "Wrong size on PrinterWidget_ShowOutputMenu");
static_assert(offsetof(PrinterWidget_ShowOutputMenu, ItemName) == 0x000000, "Member 'PrinterWidget_ShowOutputMenu::ItemName' has a wrong offset!");
static_assert(offsetof(PrinterWidget_ShowOutputMenu, OverlayPicture) == 0x000008, "Member 'PrinterWidget_ShowOutputMenu::OverlayPicture' has a wrong offset!");

// Function Phoenix.PrinterWidget.ShowShopMenu
// 0x0030 (0x0030 - 0x0000)
struct PrinterWidget_ShowShopMenu final
{
public:
	class FName                                   ItemName;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         costTotal_0;                                       // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         costMetals_0;                                      // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         costBioplastics_0;                                 // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         costChemicals_0;                                   // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ownedMetals_0;                                     // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ownedBioplastics_0;                                // 0x001C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ownedChemicals_0;                                  // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UTexture*                               OverlayPicture;                                    // 0x0028(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PrinterWidget_ShowShopMenu) == 0x000008, "Wrong alignment on PrinterWidget_ShowShopMenu");
static_assert(sizeof(PrinterWidget_ShowShopMenu) == 0x000030, "Wrong size on PrinterWidget_ShowShopMenu");
static_assert(offsetof(PrinterWidget_ShowShopMenu, ItemName) == 0x000000, "Member 'PrinterWidget_ShowShopMenu::ItemName' has a wrong offset!");
static_assert(offsetof(PrinterWidget_ShowShopMenu, costTotal_0) == 0x000008, "Member 'PrinterWidget_ShowShopMenu::costTotal_0' has a wrong offset!");
static_assert(offsetof(PrinterWidget_ShowShopMenu, costMetals_0) == 0x00000C, "Member 'PrinterWidget_ShowShopMenu::costMetals_0' has a wrong offset!");
static_assert(offsetof(PrinterWidget_ShowShopMenu, costBioplastics_0) == 0x000010, "Member 'PrinterWidget_ShowShopMenu::costBioplastics_0' has a wrong offset!");
static_assert(offsetof(PrinterWidget_ShowShopMenu, costChemicals_0) == 0x000014, "Member 'PrinterWidget_ShowShopMenu::costChemicals_0' has a wrong offset!");
static_assert(offsetof(PrinterWidget_ShowShopMenu, ownedMetals_0) == 0x000018, "Member 'PrinterWidget_ShowShopMenu::ownedMetals_0' has a wrong offset!");
static_assert(offsetof(PrinterWidget_ShowShopMenu, ownedBioplastics_0) == 0x00001C, "Member 'PrinterWidget_ShowShopMenu::ownedBioplastics_0' has a wrong offset!");
static_assert(offsetof(PrinterWidget_ShowShopMenu, ownedChemicals_0) == 0x000020, "Member 'PrinterWidget_ShowShopMenu::ownedChemicals_0' has a wrong offset!");
static_assert(offsetof(PrinterWidget_ShowShopMenu, OverlayPicture) == 0x000028, "Member 'PrinterWidget_ShowShopMenu::OverlayPicture' has a wrong offset!");

// Function Phoenix.PuzzlePad.GetCurrentWeightOnPad
// 0x0004 (0x0004 - 0x0000)
struct PuzzlePad_GetCurrentWeightOnPad final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PuzzlePad_GetCurrentWeightOnPad) == 0x000004, "Wrong alignment on PuzzlePad_GetCurrentWeightOnPad");
static_assert(sizeof(PuzzlePad_GetCurrentWeightOnPad) == 0x000004, "Wrong size on PuzzlePad_GetCurrentWeightOnPad");
static_assert(offsetof(PuzzlePad_GetCurrentWeightOnPad, ReturnValue) == 0x000000, "Member 'PuzzlePad_GetCurrentWeightOnPad::ReturnValue' has a wrong offset!");

// Function Phoenix.PuzzlePad.IsTriggeredOn
// 0x0001 (0x0001 - 0x0000)
struct PuzzlePad_IsTriggeredOn final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PuzzlePad_IsTriggeredOn) == 0x000001, "Wrong alignment on PuzzlePad_IsTriggeredOn");
static_assert(sizeof(PuzzlePad_IsTriggeredOn) == 0x000001, "Wrong size on PuzzlePad_IsTriggeredOn");
static_assert(offsetof(PuzzlePad_IsTriggeredOn, ReturnValue) == 0x000000, "Member 'PuzzlePad_IsTriggeredOn::ReturnValue' has a wrong offset!");

// Function Phoenix.PuzzlePad.OnPuzzlePadCapsuleOverlapBegin
// 0x00A8 (0x00A8 - 0x0000)
struct PuzzlePad_OnPuzzlePadCapsuleOverlapBegin final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromSweep;                                        // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             SweepResult;                                       // 0x0020(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(PuzzlePad_OnPuzzlePadCapsuleOverlapBegin) == 0x000008, "Wrong alignment on PuzzlePad_OnPuzzlePadCapsuleOverlapBegin");
static_assert(sizeof(PuzzlePad_OnPuzzlePadCapsuleOverlapBegin) == 0x0000A8, "Wrong size on PuzzlePad_OnPuzzlePadCapsuleOverlapBegin");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapBegin, OverlappedComponent) == 0x000000, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapBegin::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapBegin, OtherActor) == 0x000008, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapBegin::OtherActor' has a wrong offset!");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapBegin, OtherComp) == 0x000010, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapBegin::OtherComp' has a wrong offset!");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapBegin, OtherBodyIndex) == 0x000018, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapBegin::OtherBodyIndex' has a wrong offset!");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapBegin, bFromSweep) == 0x00001C, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapBegin::bFromSweep' has a wrong offset!");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapBegin, SweepResult) == 0x000020, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapBegin::SweepResult' has a wrong offset!");

// Function Phoenix.PuzzlePad.OnPuzzlePadCapsuleOverlapEnd
// 0x0020 (0x0020 - 0x0000)
struct PuzzlePad_OnPuzzlePadCapsuleOverlapEnd final
{
public:
	class UPrimitiveComponent*                    OverlappedComponent;                               // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OtherActor;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    OtherComp;                                         // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OtherBodyIndex;                                    // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PuzzlePad_OnPuzzlePadCapsuleOverlapEnd) == 0x000008, "Wrong alignment on PuzzlePad_OnPuzzlePadCapsuleOverlapEnd");
static_assert(sizeof(PuzzlePad_OnPuzzlePadCapsuleOverlapEnd) == 0x000020, "Wrong size on PuzzlePad_OnPuzzlePadCapsuleOverlapEnd");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapEnd, OverlappedComponent) == 0x000000, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapEnd::OverlappedComponent' has a wrong offset!");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapEnd, OtherActor) == 0x000008, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapEnd::OtherActor' has a wrong offset!");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapEnd, OtherComp) == 0x000010, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapEnd::OtherComp' has a wrong offset!");
static_assert(offsetof(PuzzlePad_OnPuzzlePadCapsuleOverlapEnd, OtherBodyIndex) == 0x000018, "Member 'PuzzlePad_OnPuzzlePadCapsuleOverlapEnd::OtherBodyIndex' has a wrong offset!");

// Function Phoenix.PuzzlePad.DoesRequirePower
// 0x0001 (0x0001 - 0x0000)
struct PuzzlePad_DoesRequirePower final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(PuzzlePad_DoesRequirePower) == 0x000001, "Wrong alignment on PuzzlePad_DoesRequirePower");
static_assert(sizeof(PuzzlePad_DoesRequirePower) == 0x000001, "Wrong size on PuzzlePad_DoesRequirePower");
static_assert(offsetof(PuzzlePad_DoesRequirePower, ReturnValue) == 0x000000, "Member 'PuzzlePad_DoesRequirePower::ReturnValue' has a wrong offset!");

// Function Phoenix.QteWidget.FinishAction
// 0x0001 (0x0001 - 0x0000)
struct QteWidget_FinishAction final
{
public:
	EPhxQteDismissType                            DismissType;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(QteWidget_FinishAction) == 0x000001, "Wrong alignment on QteWidget_FinishAction");
static_assert(sizeof(QteWidget_FinishAction) == 0x000001, "Wrong size on QteWidget_FinishAction");
static_assert(offsetof(QteWidget_FinishAction, DismissType) == 0x000000, "Member 'QteWidget_FinishAction::DismissType' has a wrong offset!");

// Function Phoenix.QteWidget.SetIcons
// 0x0018 (0x0018 - 0x0000)
struct QteWidget_SetIcons final
{
public:
	class UTexture*                               MainIcon;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture*                               AltIcon;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowLine;                                         // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(QteWidget_SetIcons) == 0x000008, "Wrong alignment on QteWidget_SetIcons");
static_assert(sizeof(QteWidget_SetIcons) == 0x000018, "Wrong size on QteWidget_SetIcons");
static_assert(offsetof(QteWidget_SetIcons, MainIcon) == 0x000000, "Member 'QteWidget_SetIcons::MainIcon' has a wrong offset!");
static_assert(offsetof(QteWidget_SetIcons, AltIcon) == 0x000008, "Member 'QteWidget_SetIcons::AltIcon' has a wrong offset!");
static_assert(offsetof(QteWidget_SetIcons, bShowLine) == 0x000010, "Member 'QteWidget_SetIcons::bShowLine' has a wrong offset!");

// Function Phoenix.QteWidget.Setup
// 0x0150 (0x0150 - 0x0000)
struct QteWidget_Setup final
{
public:
	struct FQteRequest                            InQte;                                             // 0x0000(0x0150)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(QteWidget_Setup) == 0x000008, "Wrong alignment on QteWidget_Setup");
static_assert(sizeof(QteWidget_Setup) == 0x000150, "Wrong size on QteWidget_Setup");
static_assert(offsetof(QteWidget_Setup, InQte) == 0x000000, "Member 'QteWidget_Setup::InQte' has a wrong offset!");

// Function Phoenix.QteWidget.UpdatePips
// 0x0010 (0x0010 - 0x0000)
struct QteWidget_UpdatePips final
{
public:
	struct FVector2D                              LeftPip;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              RightPip;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(QteWidget_UpdatePips) == 0x000004, "Wrong alignment on QteWidget_UpdatePips");
static_assert(sizeof(QteWidget_UpdatePips) == 0x000010, "Wrong size on QteWidget_UpdatePips");
static_assert(offsetof(QteWidget_UpdatePips, LeftPip) == 0x000000, "Member 'QteWidget_UpdatePips::LeftPip' has a wrong offset!");
static_assert(offsetof(QteWidget_UpdatePips, RightPip) == 0x000008, "Member 'QteWidget_UpdatePips::RightPip' has a wrong offset!");

// Function Phoenix.QteWidget.UpdateProgress
// 0x0004 (0x0004 - 0x0000)
struct QteWidget_UpdateProgress final
{
public:
	float                                         Progress;                                          // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(QteWidget_UpdateProgress) == 0x000004, "Wrong alignment on QteWidget_UpdateProgress");
static_assert(sizeof(QteWidget_UpdateProgress) == 0x000004, "Wrong size on QteWidget_UpdateProgress");
static_assert(offsetof(QteWidget_UpdateProgress, Progress) == 0x000000, "Member 'QteWidget_UpdateProgress::Progress' has a wrong offset!");

// Function Phoenix.QteWidget.UpdateWiggle
// 0x0010 (0x0010 - 0x0000)
struct QteWidget_UpdateWiggle final
{
public:
	struct FVector2D                              LeftPip;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              RightPip;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(QteWidget_UpdateWiggle) == 0x000004, "Wrong alignment on QteWidget_UpdateWiggle");
static_assert(sizeof(QteWidget_UpdateWiggle) == 0x000010, "Wrong size on QteWidget_UpdateWiggle");
static_assert(offsetof(QteWidget_UpdateWiggle, LeftPip) == 0x000000, "Member 'QteWidget_UpdateWiggle::LeftPip' has a wrong offset!");
static_assert(offsetof(QteWidget_UpdateWiggle, RightPip) == 0x000008, "Member 'QteWidget_UpdateWiggle::RightPip' has a wrong offset!");

// Function Phoenix.Recycler.GetInteractableComp
// 0x0008 (0x0008 - 0x0000)
struct Recycler_GetInteractableComp final
{
public:
	class UInteractableComponent*                 ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Recycler_GetInteractableComp) == 0x000008, "Wrong alignment on Recycler_GetInteractableComp");
static_assert(sizeof(Recycler_GetInteractableComp) == 0x000008, "Wrong size on Recycler_GetInteractableComp");
static_assert(offsetof(Recycler_GetInteractableComp, ReturnValue) == 0x000000, "Member 'Recycler_GetInteractableComp::ReturnValue' has a wrong offset!");

// Function Phoenix.RecyclerMainState.BeginInteract
// 0x0008 (0x0008 - 0x0000)
struct RecyclerMainState_BeginInteract final
{
public:
	class APhxCharacter*                          RecyclerUser;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RecyclerMainState_BeginInteract) == 0x000008, "Wrong alignment on RecyclerMainState_BeginInteract");
static_assert(sizeof(RecyclerMainState_BeginInteract) == 0x000008, "Wrong size on RecyclerMainState_BeginInteract");
static_assert(offsetof(RecyclerMainState_BeginInteract, RecyclerUser) == 0x000000, "Member 'RecyclerMainState_BeginInteract::RecyclerUser' has a wrong offset!");

// Function Phoenix.RecyclerMainState.StartRecycler
// 0x0008 (0x0008 - 0x0000)
struct RecyclerMainState_StartRecycler final
{
public:
	class APhxPlayerCharacter*                    RecyclerUser;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RecyclerMainState_StartRecycler) == 0x000008, "Wrong alignment on RecyclerMainState_StartRecycler");
static_assert(sizeof(RecyclerMainState_StartRecycler) == 0x000008, "Wrong size on RecyclerMainState_StartRecycler");
static_assert(offsetof(RecyclerMainState_StartRecycler, RecyclerUser) == 0x000000, "Member 'RecyclerMainState_StartRecycler::RecyclerUser' has a wrong offset!");

// Function Phoenix.ReticleWidget.OnWeaponTargetChanged
// 0x0001 (0x0001 - 0x0000)
struct ReticleWidget_OnWeaponTargetChanged final
{
public:
	EWeaponTarget                                 NewWeaponTarget;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ReticleWidget_OnWeaponTargetChanged) == 0x000001, "Wrong alignment on ReticleWidget_OnWeaponTargetChanged");
static_assert(sizeof(ReticleWidget_OnWeaponTargetChanged) == 0x000001, "Wrong size on ReticleWidget_OnWeaponTargetChanged");
static_assert(offsetof(ReticleWidget_OnWeaponTargetChanged, NewWeaponTarget) == 0x000000, "Member 'ReticleWidget_OnWeaponTargetChanged::NewWeaponTarget' has a wrong offset!");

// Function Phoenix.ReticleWidget.IsSecondaryUnlocked
// 0x0001 (0x0001 - 0x0000)
struct ReticleWidget_IsSecondaryUnlocked final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ReticleWidget_IsSecondaryUnlocked) == 0x000001, "Wrong alignment on ReticleWidget_IsSecondaryUnlocked");
static_assert(sizeof(ReticleWidget_IsSecondaryUnlocked) == 0x000001, "Wrong size on ReticleWidget_IsSecondaryUnlocked");
static_assert(offsetof(ReticleWidget_IsSecondaryUnlocked, ReturnValue) == 0x000000, "Member 'ReticleWidget_IsSecondaryUnlocked::ReturnValue' has a wrong offset!");

// Function Phoenix.RiotLeaderboardScoreBlueprintLibrary.MakeRiotLeaderboardScoreFromLeaderboardRow
// 0x0038 (0x0038 - 0x0000)
struct RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow final
{
public:
	struct FSDSLeaderboardRow                     LeaderboardRow;                                    // 0x0000(0x0030)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FRiotLeaderboardScore                  ReturnValue;                                       // 0x0030(0x0008)(Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow) == 0x000008, "Wrong alignment on RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow");
static_assert(sizeof(RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow) == 0x000038, "Wrong size on RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow");
static_assert(offsetof(RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow, LeaderboardRow) == 0x000000, "Member 'RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow::LeaderboardRow' has a wrong offset!");
static_assert(offsetof(RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow, ReturnValue) == 0x000030, "Member 'RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow::ReturnValue' has a wrong offset!");

// Function Phoenix.ScrollingButton.OnRotateTitle
// 0x0001 (0x0001 - 0x0000)
struct ScrollingButton_OnRotateTitle final
{
public:
	bool                                          bRotateRight;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScrollingButton_OnRotateTitle) == 0x000001, "Wrong alignment on ScrollingButton_OnRotateTitle");
static_assert(sizeof(ScrollingButton_OnRotateTitle) == 0x000001, "Wrong size on ScrollingButton_OnRotateTitle");
static_assert(offsetof(ScrollingButton_OnRotateTitle, bRotateRight) == 0x000000, "Member 'ScrollingButton_OnRotateTitle::bRotateRight' has a wrong offset!");

// Function Phoenix.ScrollingButton.SetLabelText
// 0x0018 (0x0018 - 0x0000)
struct ScrollingButton_SetLabelText final
{
public:
	class FText                                   NewLabelText;                                      // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScrollingButton_SetLabelText) == 0x000008, "Wrong alignment on ScrollingButton_SetLabelText");
static_assert(sizeof(ScrollingButton_SetLabelText) == 0x000018, "Wrong size on ScrollingButton_SetLabelText");
static_assert(offsetof(ScrollingButton_SetLabelText, NewLabelText) == 0x000000, "Member 'ScrollingButton_SetLabelText::NewLabelText' has a wrong offset!");

// Function Phoenix.SDSBinkMediaActor.AsyncLoadAndPlay
// 0x0048 (0x0048 - 0x0000)
struct SDSBinkMediaActor_AsyncLoadAndPlay final
{
public:
	TSoftObjectPtr<class UBinkMediaTexture>       InMediaTexture;                                    // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UStaticMeshComponent*                   InMeshComp;                                        // 0x0028(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     InSourceMaterial;                                  // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(class UMaterialInstanceDynamic* DynamicMaterialInstance)> Callback;               // 0x0038(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSBinkMediaActor_AsyncLoadAndPlay) == 0x000008, "Wrong alignment on SDSBinkMediaActor_AsyncLoadAndPlay");
static_assert(sizeof(SDSBinkMediaActor_AsyncLoadAndPlay) == 0x000048, "Wrong size on SDSBinkMediaActor_AsyncLoadAndPlay");
static_assert(offsetof(SDSBinkMediaActor_AsyncLoadAndPlay, InMediaTexture) == 0x000000, "Member 'SDSBinkMediaActor_AsyncLoadAndPlay::InMediaTexture' has a wrong offset!");
static_assert(offsetof(SDSBinkMediaActor_AsyncLoadAndPlay, InMeshComp) == 0x000028, "Member 'SDSBinkMediaActor_AsyncLoadAndPlay::InMeshComp' has a wrong offset!");
static_assert(offsetof(SDSBinkMediaActor_AsyncLoadAndPlay, InSourceMaterial) == 0x000030, "Member 'SDSBinkMediaActor_AsyncLoadAndPlay::InSourceMaterial' has a wrong offset!");
static_assert(offsetof(SDSBinkMediaActor_AsyncLoadAndPlay, Callback) == 0x000038, "Member 'SDSBinkMediaActor_AsyncLoadAndPlay::Callback' has a wrong offset!");

// Function Phoenix.SDSBinkMediaActor.CreateDynamicMaterial
// 0x0038 (0x0038 - 0x0000)
struct SDSBinkMediaActor_CreateDynamicMaterial final
{
public:
	TSoftObjectPtr<class UBinkMediaTexture>       InMediaTexture;                                    // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UStaticMeshComponent*                   InMeshComp;                                        // 0x0028(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     InSourceMaterial;                                  // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSBinkMediaActor_CreateDynamicMaterial) == 0x000008, "Wrong alignment on SDSBinkMediaActor_CreateDynamicMaterial");
static_assert(sizeof(SDSBinkMediaActor_CreateDynamicMaterial) == 0x000038, "Wrong size on SDSBinkMediaActor_CreateDynamicMaterial");
static_assert(offsetof(SDSBinkMediaActor_CreateDynamicMaterial, InMediaTexture) == 0x000000, "Member 'SDSBinkMediaActor_CreateDynamicMaterial::InMediaTexture' has a wrong offset!");
static_assert(offsetof(SDSBinkMediaActor_CreateDynamicMaterial, InMeshComp) == 0x000028, "Member 'SDSBinkMediaActor_CreateDynamicMaterial::InMeshComp' has a wrong offset!");
static_assert(offsetof(SDSBinkMediaActor_CreateDynamicMaterial, InSourceMaterial) == 0x000030, "Member 'SDSBinkMediaActor_CreateDynamicMaterial::InSourceMaterial' has a wrong offset!");

// Function Phoenix.SDSBinkMediaActor.SetMediaTexture
// 0x0028 (0x0028 - 0x0000)
struct SDSBinkMediaActor_SetMediaTexture final
{
public:
	TSoftObjectPtr<class UBinkMediaTexture>       InMediaTexture;                                    // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSBinkMediaActor_SetMediaTexture) == 0x000008, "Wrong alignment on SDSBinkMediaActor_SetMediaTexture");
static_assert(sizeof(SDSBinkMediaActor_SetMediaTexture) == 0x000028, "Wrong size on SDSBinkMediaActor_SetMediaTexture");
static_assert(offsetof(SDSBinkMediaActor_SetMediaTexture, InMediaTexture) == 0x000000, "Member 'SDSBinkMediaActor_SetMediaTexture::InMediaTexture' has a wrong offset!");

// Function Phoenix.SDSBinkMediaActor.SetSoundEvent
// 0x0028 (0x0028 - 0x0000)
struct SDSBinkMediaActor_SetSoundEvent final
{
public:
	TSoftObjectPtr<class UAkAudioEvent>           InSoundEvent;                                      // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSBinkMediaActor_SetSoundEvent) == 0x000008, "Wrong alignment on SDSBinkMediaActor_SetSoundEvent");
static_assert(sizeof(SDSBinkMediaActor_SetSoundEvent) == 0x000028, "Wrong size on SDSBinkMediaActor_SetSoundEvent");
static_assert(offsetof(SDSBinkMediaActor_SetSoundEvent, InSoundEvent) == 0x000000, "Member 'SDSBinkMediaActor_SetSoundEvent::InSoundEvent' has a wrong offset!");

// Function Phoenix.SDSBinkMediaActor.GetDynamicMaterialInstance
// 0x0008 (0x0008 - 0x0000)
struct SDSBinkMediaActor_GetDynamicMaterialInstance final
{
public:
	class UMaterialInstanceDynamic*               ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSBinkMediaActor_GetDynamicMaterialInstance) == 0x000008, "Wrong alignment on SDSBinkMediaActor_GetDynamicMaterialInstance");
static_assert(sizeof(SDSBinkMediaActor_GetDynamicMaterialInstance) == 0x000008, "Wrong size on SDSBinkMediaActor_GetDynamicMaterialInstance");
static_assert(offsetof(SDSBinkMediaActor_GetDynamicMaterialInstance, ReturnValue) == 0x000000, "Member 'SDSBinkMediaActor_GetDynamicMaterialInstance::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSDirectionInputHandler.DirectionInput
// 0x0002 (0x0002 - 0x0000)
struct SDSDirectionInputHandler_DirectionInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromPlayerMoveBinding;                            // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSDirectionInputHandler_DirectionInput) == 0x000001, "Wrong alignment on SDSDirectionInputHandler_DirectionInput");
static_assert(sizeof(SDSDirectionInputHandler_DirectionInput) == 0x000002, "Wrong size on SDSDirectionInputHandler_DirectionInput");
static_assert(offsetof(SDSDirectionInputHandler_DirectionInput, Direction) == 0x000000, "Member 'SDSDirectionInputHandler_DirectionInput::Direction' has a wrong offset!");
static_assert(offsetof(SDSDirectionInputHandler_DirectionInput, bFromPlayerMoveBinding) == 0x000001, "Member 'SDSDirectionInputHandler_DirectionInput::bFromPlayerMoveBinding' has a wrong offset!");

// Function Phoenix.SDSGridWidget.GetAdjacent
// 0x0018 (0x0018 - 0x0000)
struct SDSGridWidget_GetAdjacent final
{
public:
	const class UPhxSelectable*                   Target;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputDirection                               Direction;                                         // 0x0008(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhxSelectable*                         ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSGridWidget_GetAdjacent) == 0x000008, "Wrong alignment on SDSGridWidget_GetAdjacent");
static_assert(sizeof(SDSGridWidget_GetAdjacent) == 0x000018, "Wrong size on SDSGridWidget_GetAdjacent");
static_assert(offsetof(SDSGridWidget_GetAdjacent, Target) == 0x000000, "Member 'SDSGridWidget_GetAdjacent::Target' has a wrong offset!");
static_assert(offsetof(SDSGridWidget_GetAdjacent, Direction) == 0x000008, "Member 'SDSGridWidget_GetAdjacent::Direction' has a wrong offset!");
static_assert(offsetof(SDSGridWidget_GetAdjacent, ReturnValue) == 0x000010, "Member 'SDSGridWidget_GetAdjacent::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSGridWidget.IsSelectable
// 0x0010 (0x0010 - 0x0000)
struct SDSGridWidget_IsSelectable final
{
public:
	const class UPhxSelectable*                   Target;                                            // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0008(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(SDSGridWidget_IsSelectable) == 0x000008, "Wrong alignment on SDSGridWidget_IsSelectable");
static_assert(sizeof(SDSGridWidget_IsSelectable) == 0x000010, "Wrong size on SDSGridWidget_IsSelectable");
static_assert(offsetof(SDSGridWidget_IsSelectable, Target) == 0x000000, "Member 'SDSGridWidget_IsSelectable::Target' has a wrong offset!");
static_assert(offsetof(SDSGridWidget_IsSelectable, ReturnValue) == 0x000008, "Member 'SDSGridWidget_IsSelectable::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSGridWidget.PlayGlobalSound
// 0x0008 (0x0008 - 0x0000)
struct SDSGridWidget_PlayGlobalSound final
{
public:
	const class UAkAudioEvent*                    Sound;                                             // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSGridWidget_PlayGlobalSound) == 0x000008, "Wrong alignment on SDSGridWidget_PlayGlobalSound");
static_assert(sizeof(SDSGridWidget_PlayGlobalSound) == 0x000008, "Wrong size on SDSGridWidget_PlayGlobalSound");
static_assert(offsetof(SDSGridWidget_PlayGlobalSound, Sound) == 0x000000, "Member 'SDSGridWidget_PlayGlobalSound::Sound' has a wrong offset!");

// Function Phoenix.SDSGridWidget.SetActiveContainer
// 0x0008 (0x0008 - 0x0000)
struct SDSGridWidget_SetActiveContainer final
{
public:
	class UGridPanel*                             ActiveGridPanel;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSGridWidget_SetActiveContainer) == 0x000008, "Wrong alignment on SDSGridWidget_SetActiveContainer");
static_assert(sizeof(SDSGridWidget_SetActiveContainer) == 0x000008, "Wrong size on SDSGridWidget_SetActiveContainer");
static_assert(offsetof(SDSGridWidget_SetActiveContainer, ActiveGridPanel) == 0x000000, "Member 'SDSGridWidget_SetActiveContainer::ActiveGridPanel' has a wrong offset!");

// Function Phoenix.SDSGridWidget.GetSelected
// 0x0008 (0x0008 - 0x0000)
struct SDSGridWidget_GetSelected final
{
public:
	class UPhxSelectable*                         ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSGridWidget_GetSelected) == 0x000008, "Wrong alignment on SDSGridWidget_GetSelected");
static_assert(sizeof(SDSGridWidget_GetSelected) == 0x000008, "Wrong size on SDSGridWidget_GetSelected");
static_assert(offsetof(SDSGridWidget_GetSelected, ReturnValue) == 0x000000, "Member 'SDSGridWidget_GetSelected::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSKeycodeHintButton.SetLore
// 0x0018 (0x0018 - 0x0000)
struct SDSKeycodeHintButton_SetLore final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSKeycodeHintButton_SetLore) == 0x000008, "Wrong alignment on SDSKeycodeHintButton_SetLore");
static_assert(sizeof(SDSKeycodeHintButton_SetLore) == 0x000018, "Wrong size on SDSKeycodeHintButton_SetLore");
static_assert(offsetof(SDSKeycodeHintButton_SetLore, InText) == 0x000000, "Member 'SDSKeycodeHintButton_SetLore::InText' has a wrong offset!");

// Function Phoenix.SDSKeycodeHintButton.SetThumbnail
// 0x0028 (0x0028 - 0x0000)
struct SDSKeycodeHintButton_SetThumbnail final
{
public:
	TSoftObjectPtr<class UTexture2D>              InSoftTexture;                                     // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSKeycodeHintButton_SetThumbnail) == 0x000008, "Wrong alignment on SDSKeycodeHintButton_SetThumbnail");
static_assert(sizeof(SDSKeycodeHintButton_SetThumbnail) == 0x000028, "Wrong size on SDSKeycodeHintButton_SetThumbnail");
static_assert(offsetof(SDSKeycodeHintButton_SetThumbnail, InSoftTexture) == 0x000000, "Member 'SDSKeycodeHintButton_SetThumbnail::InSoftTexture' has a wrong offset!");

// Function Phoenix.SDSLeftStickInputHandler.LeftStickInput
// 0x0001 (0x0001 - 0x0000)
struct SDSLeftStickInputHandler_LeftStickInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSLeftStickInputHandler_LeftStickInput) == 0x000001, "Wrong alignment on SDSLeftStickInputHandler_LeftStickInput");
static_assert(sizeof(SDSLeftStickInputHandler_LeftStickInput) == 0x000001, "Wrong size on SDSLeftStickInputHandler_LeftStickInput");
static_assert(offsetof(SDSLeftStickInputHandler_LeftStickInput, Direction) == 0x000000, "Member 'SDSLeftStickInputHandler_LeftStickInput::Direction' has a wrong offset!");

// Function Phoenix.SDSUISystem.Get
// 0x0010 (0x0010 - 0x0000)
struct SDSUISystem_Get final
{
public:
	const class UObject*                          WorldContextObject;                                // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USDSUISystem*                           ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_Get) == 0x000008, "Wrong alignment on SDSUISystem_Get");
static_assert(sizeof(SDSUISystem_Get) == 0x000010, "Wrong size on SDSUISystem_Get");
static_assert(offsetof(SDSUISystem_Get, WorldContextObject) == 0x000000, "Member 'SDSUISystem_Get::WorldContextObject' has a wrong offset!");
static_assert(offsetof(SDSUISystem_Get, ReturnValue) == 0x000008, "Member 'SDSUISystem_Get::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.DirectionInput
// 0x0002 (0x0002 - 0x0000)
struct SDSUISystem_DirectionInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromPlayerMoveBinding;                            // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_DirectionInput) == 0x000001, "Wrong alignment on SDSUISystem_DirectionInput");
static_assert(sizeof(SDSUISystem_DirectionInput) == 0x000002, "Wrong size on SDSUISystem_DirectionInput");
static_assert(offsetof(SDSUISystem_DirectionInput, Direction) == 0x000000, "Member 'SDSUISystem_DirectionInput::Direction' has a wrong offset!");
static_assert(offsetof(SDSUISystem_DirectionInput, bFromPlayerMoveBinding) == 0x000001, "Member 'SDSUISystem_DirectionInput::bFromPlayerMoveBinding' has a wrong offset!");

// Function Phoenix.SDSUISystem.DisplayWarningNotification
// 0x0018 (0x0018 - 0x0000)
struct SDSUISystem_DisplayWarningNotification final
{
public:
	class FText                                   InMessage;                                         // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_DisplayWarningNotification) == 0x000008, "Wrong alignment on SDSUISystem_DisplayWarningNotification");
static_assert(sizeof(SDSUISystem_DisplayWarningNotification) == 0x000018, "Wrong size on SDSUISystem_DisplayWarningNotification");
static_assert(offsetof(SDSUISystem_DisplayWarningNotification, InMessage) == 0x000000, "Member 'SDSUISystem_DisplayWarningNotification::InMessage' has a wrong offset!");

// Function Phoenix.SDSUISystem.ForceUICompositeModeKeepEnable
// 0x0001 (0x0001 - 0x0000)
struct SDSUISystem_ForceUICompositeModeKeepEnable final
{
public:
	bool                                          bEnable;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_ForceUICompositeModeKeepEnable) == 0x000001, "Wrong alignment on SDSUISystem_ForceUICompositeModeKeepEnable");
static_assert(sizeof(SDSUISystem_ForceUICompositeModeKeepEnable) == 0x000001, "Wrong size on SDSUISystem_ForceUICompositeModeKeepEnable");
static_assert(offsetof(SDSUISystem_ForceUICompositeModeKeepEnable, bEnable) == 0x000000, "Member 'SDSUISystem_ForceUICompositeModeKeepEnable::bEnable' has a wrong offset!");

// Function Phoenix.SDSUISystem.GetSDSToolTipWidget
// 0x0008 (0x0008 - 0x0000)
struct SDSUISystem_GetSDSToolTipWidget final
{
public:
	class UUserWidget*                            ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_GetSDSToolTipWidget) == 0x000008, "Wrong alignment on SDSUISystem_GetSDSToolTipWidget");
static_assert(sizeof(SDSUISystem_GetSDSToolTipWidget) == 0x000008, "Wrong size on SDSUISystem_GetSDSToolTipWidget");
static_assert(offsetof(SDSUISystem_GetSDSToolTipWidget, ReturnValue) == 0x000000, "Member 'SDSUISystem_GetSDSToolTipWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.LeftStickInput
// 0x0001 (0x0001 - 0x0000)
struct SDSUISystem_LeftStickInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_LeftStickInput) == 0x000001, "Wrong alignment on SDSUISystem_LeftStickInput");
static_assert(sizeof(SDSUISystem_LeftStickInput) == 0x000001, "Wrong size on SDSUISystem_LeftStickInput");
static_assert(offsetof(SDSUISystem_LeftStickInput, Direction) == 0x000000, "Member 'SDSUISystem_LeftStickInput::Direction' has a wrong offset!");

// Function Phoenix.SDSUISystem.MoveForward
// 0x0004 (0x0004 - 0x0000)
struct SDSUISystem_MoveForward final
{
public:
	float                                         Value;                                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_MoveForward) == 0x000004, "Wrong alignment on SDSUISystem_MoveForward");
static_assert(sizeof(SDSUISystem_MoveForward) == 0x000004, "Wrong size on SDSUISystem_MoveForward");
static_assert(offsetof(SDSUISystem_MoveForward, Value) == 0x000000, "Member 'SDSUISystem_MoveForward::Value' has a wrong offset!");

// Function Phoenix.SDSUISystem.MoveRight
// 0x0004 (0x0004 - 0x0000)
struct SDSUISystem_MoveRight final
{
public:
	float                                         Value;                                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_MoveRight) == 0x000004, "Wrong alignment on SDSUISystem_MoveRight");
static_assert(sizeof(SDSUISystem_MoveRight) == 0x000004, "Wrong size on SDSUISystem_MoveRight");
static_assert(offsetof(SDSUISystem_MoveRight, Value) == 0x000000, "Member 'SDSUISystem_MoveRight::Value' has a wrong offset!");

// Function Phoenix.SDSUISystem.OnSubtitlesUpdated
// 0x0030 (0x0030 - 0x0000)
struct SDSUISystem_OnSubtitlesUpdated final
{
public:
	class FText                                   PrimaryText;                                       // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class FText                                   SecondaryText;                                     // 0x0018(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_OnSubtitlesUpdated) == 0x000008, "Wrong alignment on SDSUISystem_OnSubtitlesUpdated");
static_assert(sizeof(SDSUISystem_OnSubtitlesUpdated) == 0x000030, "Wrong size on SDSUISystem_OnSubtitlesUpdated");
static_assert(offsetof(SDSUISystem_OnSubtitlesUpdated, PrimaryText) == 0x000000, "Member 'SDSUISystem_OnSubtitlesUpdated::PrimaryText' has a wrong offset!");
static_assert(offsetof(SDSUISystem_OnSubtitlesUpdated, SecondaryText) == 0x000018, "Member 'SDSUISystem_OnSubtitlesUpdated::SecondaryText' has a wrong offset!");

// Function Phoenix.SDSUISystem.PushWidget
// 0x0010 (0x0010 - 0x0000)
struct SDSUISystem_PushWidget final
{
public:
	class UUserWidget*                            InWidget;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAddToViewport;                                    // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(SDSUISystem_PushWidget) == 0x000008, "Wrong alignment on SDSUISystem_PushWidget");
static_assert(sizeof(SDSUISystem_PushWidget) == 0x000010, "Wrong size on SDSUISystem_PushWidget");
static_assert(offsetof(SDSUISystem_PushWidget, InWidget) == 0x000000, "Member 'SDSUISystem_PushWidget::InWidget' has a wrong offset!");
static_assert(offsetof(SDSUISystem_PushWidget, bAddToViewport) == 0x000008, "Member 'SDSUISystem_PushWidget::bAddToViewport' has a wrong offset!");

// Function Phoenix.SDSUISystem.QuickSwapDirectionInput
// 0x0002 (0x0002 - 0x0000)
struct SDSUISystem_QuickSwapDirectionInput final
{
public:
	EInputDirection                               Direction;                                         // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFromPlayerMoveBinding;                            // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_QuickSwapDirectionInput) == 0x000001, "Wrong alignment on SDSUISystem_QuickSwapDirectionInput");
static_assert(sizeof(SDSUISystem_QuickSwapDirectionInput) == 0x000002, "Wrong size on SDSUISystem_QuickSwapDirectionInput");
static_assert(offsetof(SDSUISystem_QuickSwapDirectionInput, Direction) == 0x000000, "Member 'SDSUISystem_QuickSwapDirectionInput::Direction' has a wrong offset!");
static_assert(offsetof(SDSUISystem_QuickSwapDirectionInput, bFromPlayerMoveBinding) == 0x000001, "Member 'SDSUISystem_QuickSwapDirectionInput::bFromPlayerMoveBinding' has a wrong offset!");

// Function Phoenix.SDSUISystem.RemoveWidget
// 0x0008 (0x0008 - 0x0000)
struct SDSUISystem_RemoveWidget final
{
public:
	class UUserWidget*                            Widget;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_RemoveWidget) == 0x000008, "Wrong alignment on SDSUISystem_RemoveWidget");
static_assert(sizeof(SDSUISystem_RemoveWidget) == 0x000008, "Wrong size on SDSUISystem_RemoveWidget");
static_assert(offsetof(SDSUISystem_RemoveWidget, Widget) == 0x000000, "Member 'SDSUISystem_RemoveWidget::Widget' has a wrong offset!");

// Function Phoenix.SDSUISystem.RequestBackgroundScreen
// 0x0010 (0x0010 - 0x0000)
struct SDSUISystem_RequestBackgroundScreen final
{
public:
	TSubclassOf<class USDSScreenWidget>           BackgroundScreen;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USDSScreenWidget*                       ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_RequestBackgroundScreen) == 0x000008, "Wrong alignment on SDSUISystem_RequestBackgroundScreen");
static_assert(sizeof(SDSUISystem_RequestBackgroundScreen) == 0x000010, "Wrong size on SDSUISystem_RequestBackgroundScreen");
static_assert(offsetof(SDSUISystem_RequestBackgroundScreen, BackgroundScreen) == 0x000000, "Member 'SDSUISystem_RequestBackgroundScreen::BackgroundScreen' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestBackgroundScreen, ReturnValue) == 0x000008, "Member 'SDSUISystem_RequestBackgroundScreen::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.RequestOneButtonPrompt
// 0x0030 (0x0030 - 0x0000)
struct SDSUISystem_RequestOneButtonPrompt final
{
public:
	class FText                                   InMessage;                                         // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnConfirm;                                         // 0x0018(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TSubclassOf<class USDSPromptWidget>           PromptClass;                                       // 0x0028(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_RequestOneButtonPrompt) == 0x000008, "Wrong alignment on SDSUISystem_RequestOneButtonPrompt");
static_assert(sizeof(SDSUISystem_RequestOneButtonPrompt) == 0x000030, "Wrong size on SDSUISystem_RequestOneButtonPrompt");
static_assert(offsetof(SDSUISystem_RequestOneButtonPrompt, InMessage) == 0x000000, "Member 'SDSUISystem_RequestOneButtonPrompt::InMessage' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestOneButtonPrompt, OnConfirm) == 0x000018, "Member 'SDSUISystem_RequestOneButtonPrompt::OnConfirm' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestOneButtonPrompt, PromptClass) == 0x000028, "Member 'SDSUISystem_RequestOneButtonPrompt::PromptClass' has a wrong offset!");

// Function Phoenix.SDSUISystem.RequestProgressPrompt
// 0x0040 (0x0040 - 0x0000)
struct SDSUISystem_RequestProgressPrompt final
{
public:
	class FText                                   InMessage;                                         // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	float                                         StartValue;                                        // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnCancel;                                          // 0x001C(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class USDSPromptWidget>           PromptClass;                                       // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USDSPromptWidgetProgress*               ReturnValue;                                       // 0x0038(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_RequestProgressPrompt) == 0x000008, "Wrong alignment on SDSUISystem_RequestProgressPrompt");
static_assert(sizeof(SDSUISystem_RequestProgressPrompt) == 0x000040, "Wrong size on SDSUISystem_RequestProgressPrompt");
static_assert(offsetof(SDSUISystem_RequestProgressPrompt, InMessage) == 0x000000, "Member 'SDSUISystem_RequestProgressPrompt::InMessage' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestProgressPrompt, StartValue) == 0x000018, "Member 'SDSUISystem_RequestProgressPrompt::StartValue' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestProgressPrompt, OnCancel) == 0x00001C, "Member 'SDSUISystem_RequestProgressPrompt::OnCancel' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestProgressPrompt, PromptClass) == 0x000030, "Member 'SDSUISystem_RequestProgressPrompt::PromptClass' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestProgressPrompt, ReturnValue) == 0x000038, "Member 'SDSUISystem_RequestProgressPrompt::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.RequestScreen
// 0x0060 (0x0060 - 0x0000)
struct SDSUISystem_RequestScreen final
{
public:
	TSoftClassPtr<class UClass>                   ScreenClass;                                       // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(class USDSScreenWidget* NewScreen)> Callback;                                     // 0x0028(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	class APlayerController*                      InController;                                      // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bHideCurrent;                                      // 0x0040(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_41[0x7];                                       // 0x0041(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class FText                                   BreadcrumbOverride;                                // 0x0048(0x0018)(ConstParm, Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_RequestScreen) == 0x000008, "Wrong alignment on SDSUISystem_RequestScreen");
static_assert(sizeof(SDSUISystem_RequestScreen) == 0x000060, "Wrong size on SDSUISystem_RequestScreen");
static_assert(offsetof(SDSUISystem_RequestScreen, ScreenClass) == 0x000000, "Member 'SDSUISystem_RequestScreen::ScreenClass' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestScreen, Callback) == 0x000028, "Member 'SDSUISystem_RequestScreen::Callback' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestScreen, InController) == 0x000038, "Member 'SDSUISystem_RequestScreen::InController' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestScreen, bHideCurrent) == 0x000040, "Member 'SDSUISystem_RequestScreen::bHideCurrent' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestScreen, BreadcrumbOverride) == 0x000048, "Member 'SDSUISystem_RequestScreen::BreadcrumbOverride' has a wrong offset!");

// Function Phoenix.SDSUISystem.RequestSimpleNotification
// 0x0028 (0x0028 - 0x0000)
struct SDSUISystem_RequestSimpleNotification final
{
public:
	class FText                                   InMessage;                                         // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	TSubclassOf<class USDSSimpleNotification>     NotificationClass;                                 // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USDSSimpleNotification*                 ReturnValue;                                       // 0x0020(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_RequestSimpleNotification) == 0x000008, "Wrong alignment on SDSUISystem_RequestSimpleNotification");
static_assert(sizeof(SDSUISystem_RequestSimpleNotification) == 0x000028, "Wrong size on SDSUISystem_RequestSimpleNotification");
static_assert(offsetof(SDSUISystem_RequestSimpleNotification, InMessage) == 0x000000, "Member 'SDSUISystem_RequestSimpleNotification::InMessage' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestSimpleNotification, NotificationClass) == 0x000018, "Member 'SDSUISystem_RequestSimpleNotification::NotificationClass' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestSimpleNotification, ReturnValue) == 0x000020, "Member 'SDSUISystem_RequestSimpleNotification::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.RequestTwoButtonPrompt
// 0x0040 (0x0040 - 0x0000)
struct SDSUISystem_RequestTwoButtonPrompt final
{
public:
	class FText                                   InMessage;                                         // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnConfirm;                                         // 0x0018(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnCancel;                                          // 0x0028(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TSubclassOf<class USDSPromptWidget>           PromptClass;                                       // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_RequestTwoButtonPrompt) == 0x000008, "Wrong alignment on SDSUISystem_RequestTwoButtonPrompt");
static_assert(sizeof(SDSUISystem_RequestTwoButtonPrompt) == 0x000040, "Wrong size on SDSUISystem_RequestTwoButtonPrompt");
static_assert(offsetof(SDSUISystem_RequestTwoButtonPrompt, InMessage) == 0x000000, "Member 'SDSUISystem_RequestTwoButtonPrompt::InMessage' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestTwoButtonPrompt, OnConfirm) == 0x000018, "Member 'SDSUISystem_RequestTwoButtonPrompt::OnConfirm' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestTwoButtonPrompt, OnCancel) == 0x000028, "Member 'SDSUISystem_RequestTwoButtonPrompt::OnCancel' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestTwoButtonPrompt, PromptClass) == 0x000038, "Member 'SDSUISystem_RequestTwoButtonPrompt::PromptClass' has a wrong offset!");

// Function Phoenix.SDSUISystem.RequestTwoButtonPromptExtended
// 0x0040 (0x0040 - 0x0000)
struct SDSUISystem_RequestTwoButtonPromptExtended final
{
public:
	class FText                                   InMessage;                                         // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnConfirm;                                         // 0x0018(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnCancel;                                          // 0x0028(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TSubclassOf<class USDSPromptWidget>           PromptClass;                                       // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_RequestTwoButtonPromptExtended) == 0x000008, "Wrong alignment on SDSUISystem_RequestTwoButtonPromptExtended");
static_assert(sizeof(SDSUISystem_RequestTwoButtonPromptExtended) == 0x000040, "Wrong size on SDSUISystem_RequestTwoButtonPromptExtended");
static_assert(offsetof(SDSUISystem_RequestTwoButtonPromptExtended, InMessage) == 0x000000, "Member 'SDSUISystem_RequestTwoButtonPromptExtended::InMessage' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestTwoButtonPromptExtended, OnConfirm) == 0x000018, "Member 'SDSUISystem_RequestTwoButtonPromptExtended::OnConfirm' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestTwoButtonPromptExtended, OnCancel) == 0x000028, "Member 'SDSUISystem_RequestTwoButtonPromptExtended::OnCancel' has a wrong offset!");
static_assert(offsetof(SDSUISystem_RequestTwoButtonPromptExtended, PromptClass) == 0x000038, "Member 'SDSUISystem_RequestTwoButtonPromptExtended::PromptClass' has a wrong offset!");

// Function Phoenix.SDSUISystem.SetModalDialogOpen
// 0x0001 (0x0001 - 0x0000)
struct SDSUISystem_SetModalDialogOpen final
{
public:
	bool                                          bIsOpen;                                           // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_SetModalDialogOpen) == 0x000001, "Wrong alignment on SDSUISystem_SetModalDialogOpen");
static_assert(sizeof(SDSUISystem_SetModalDialogOpen) == 0x000001, "Wrong size on SDSUISystem_SetModalDialogOpen");
static_assert(offsetof(SDSUISystem_SetModalDialogOpen, bIsOpen) == 0x000000, "Member 'SDSUISystem_SetModalDialogOpen::bIsOpen' has a wrong offset!");

// Function Phoenix.SDSUISystem.GetBackgroundScreen
// 0x0008 (0x0008 - 0x0000)
struct SDSUISystem_GetBackgroundScreen final
{
public:
	class USDSScreenWidget*                       ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_GetBackgroundScreen) == 0x000008, "Wrong alignment on SDSUISystem_GetBackgroundScreen");
static_assert(sizeof(SDSUISystem_GetBackgroundScreen) == 0x000008, "Wrong size on SDSUISystem_GetBackgroundScreen");
static_assert(offsetof(SDSUISystem_GetBackgroundScreen, ReturnValue) == 0x000000, "Member 'SDSUISystem_GetBackgroundScreen::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.GetTopWidget
// 0x0008 (0x0008 - 0x0000)
struct SDSUISystem_GetTopWidget final
{
public:
	class UUserWidget*                            ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_GetTopWidget) == 0x000008, "Wrong alignment on SDSUISystem_GetTopWidget");
static_assert(sizeof(SDSUISystem_GetTopWidget) == 0x000008, "Wrong size on SDSUISystem_GetTopWidget");
static_assert(offsetof(SDSUISystem_GetTopWidget, ReturnValue) == 0x000000, "Member 'SDSUISystem_GetTopWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.IsActive
// 0x0001 (0x0001 - 0x0000)
struct SDSUISystem_IsActive final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_IsActive) == 0x000001, "Wrong alignment on SDSUISystem_IsActive");
static_assert(sizeof(SDSUISystem_IsActive) == 0x000001, "Wrong size on SDSUISystem_IsActive");
static_assert(offsetof(SDSUISystem_IsActive, ReturnValue) == 0x000000, "Member 'SDSUISystem_IsActive::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.IsBootNotificationsEnabled
// 0x0001 (0x0001 - 0x0000)
struct SDSUISystem_IsBootNotificationsEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_IsBootNotificationsEnabled) == 0x000001, "Wrong alignment on SDSUISystem_IsBootNotificationsEnabled");
static_assert(sizeof(SDSUISystem_IsBootNotificationsEnabled) == 0x000001, "Wrong size on SDSUISystem_IsBootNotificationsEnabled");
static_assert(offsetof(SDSUISystem_IsBootNotificationsEnabled, ReturnValue) == 0x000000, "Member 'SDSUISystem_IsBootNotificationsEnabled::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.IsInEndingCredits
// 0x0001 (0x0001 - 0x0000)
struct SDSUISystem_IsInEndingCredits final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_IsInEndingCredits) == 0x000001, "Wrong alignment on SDSUISystem_IsInEndingCredits");
static_assert(sizeof(SDSUISystem_IsInEndingCredits) == 0x000001, "Wrong size on SDSUISystem_IsInEndingCredits");
static_assert(offsetof(SDSUISystem_IsInEndingCredits, ReturnValue) == 0x000000, "Member 'SDSUISystem_IsInEndingCredits::ReturnValue' has a wrong offset!");

// Function Phoenix.SDSUISystem.IsModalDialogOpen
// 0x0001 (0x0001 - 0x0000)
struct SDSUISystem_IsModalDialogOpen final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SDSUISystem_IsModalDialogOpen) == 0x000001, "Wrong alignment on SDSUISystem_IsModalDialogOpen");
static_assert(sizeof(SDSUISystem_IsModalDialogOpen) == 0x000001, "Wrong size on SDSUISystem_IsModalDialogOpen");
static_assert(offsetof(SDSUISystem_IsModalDialogOpen, ReturnValue) == 0x000000, "Member 'SDSUISystem_IsModalDialogOpen::ReturnValue' has a wrong offset!");

// Function Phoenix.SoundControllerComponent.PlaySound
// 0x0001 (0x0001 - 0x0000)
struct SoundControllerComponent_PlaySound final
{
public:
	bool                                          bForce;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SoundControllerComponent_PlaySound) == 0x000001, "Wrong alignment on SoundControllerComponent_PlaySound");
static_assert(sizeof(SoundControllerComponent_PlaySound) == 0x000001, "Wrong size on SoundControllerComponent_PlaySound");
static_assert(offsetof(SoundControllerComponent_PlaySound, bForce) == 0x000000, "Member 'SoundControllerComponent_PlaySound::bForce' has a wrong offset!");

// Function Phoenix.SoundControllerComponent.SelectSound
// 0x0010 (0x0010 - 0x0000)
struct SoundControllerComponent_SelectSound final
{
public:
	class UAkAudioEvent*                          SoundId;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRepeatSound;                                      // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Interval;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SoundControllerComponent_SelectSound) == 0x000008, "Wrong alignment on SoundControllerComponent_SelectSound");
static_assert(sizeof(SoundControllerComponent_SelectSound) == 0x000010, "Wrong size on SoundControllerComponent_SelectSound");
static_assert(offsetof(SoundControllerComponent_SelectSound, SoundId) == 0x000000, "Member 'SoundControllerComponent_SelectSound::SoundId' has a wrong offset!");
static_assert(offsetof(SoundControllerComponent_SelectSound, bRepeatSound) == 0x000008, "Member 'SoundControllerComponent_SelectSound::bRepeatSound' has a wrong offset!");
static_assert(offsetof(SoundControllerComponent_SelectSound, Interval) == 0x00000C, "Member 'SoundControllerComponent_SelectSound::Interval' has a wrong offset!");

// Function Phoenix.SoundControllerComponent.StopSound
// 0x0001 (0x0001 - 0x0000)
struct SoundControllerComponent_StopSound final
{
public:
	bool                                          bForce;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SoundControllerComponent_StopSound) == 0x000001, "Wrong alignment on SoundControllerComponent_StopSound");
static_assert(sizeof(SoundControllerComponent_StopSound) == 0x000001, "Wrong size on SoundControllerComponent_StopSound");
static_assert(offsetof(SoundControllerComponent_StopSound, bForce) == 0x000000, "Member 'SoundControllerComponent_StopSound::bForce' has a wrong offset!");

// Function Phoenix.TitleScreenWidget.ChangeButtonText
// 0x0004 (0x0004 - 0x0000)
struct TitleScreenWidget_ChangeButtonText final
{
public:
	int32                                         ButtonIndex;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TitleScreenWidget_ChangeButtonText) == 0x000004, "Wrong alignment on TitleScreenWidget_ChangeButtonText");
static_assert(sizeof(TitleScreenWidget_ChangeButtonText) == 0x000004, "Wrong size on TitleScreenWidget_ChangeButtonText");
static_assert(offsetof(TitleScreenWidget_ChangeButtonText, ButtonIndex) == 0x000000, "Member 'TitleScreenWidget_ChangeButtonText::ButtonIndex' has a wrong offset!");

// Function Phoenix.TitleScreenWidget.OnRotateTitle
// 0x0001 (0x0001 - 0x0000)
struct TitleScreenWidget_OnRotateTitle final
{
public:
	bool                                          bRotateRight;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TitleScreenWidget_OnRotateTitle) == 0x000001, "Wrong alignment on TitleScreenWidget_OnRotateTitle");
static_assert(sizeof(TitleScreenWidget_OnRotateTitle) == 0x000001, "Wrong size on TitleScreenWidget_OnRotateTitle");
static_assert(offsetof(TitleScreenWidget_OnRotateTitle, bRotateRight) == 0x000000, "Member 'TitleScreenWidget_OnRotateTitle::bRotateRight' has a wrong offset!");

// Function Phoenix.TitleScreenWidget.GetLevelSelectWidget
// 0x0008 (0x0008 - 0x0000)
struct TitleScreenWidget_GetLevelSelectWidget final
{
public:
	class ULevelSelectWidget*                     ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TitleScreenWidget_GetLevelSelectWidget) == 0x000008, "Wrong alignment on TitleScreenWidget_GetLevelSelectWidget");
static_assert(sizeof(TitleScreenWidget_GetLevelSelectWidget) == 0x000008, "Wrong size on TitleScreenWidget_GetLevelSelectWidget");
static_assert(offsetof(TitleScreenWidget_GetLevelSelectWidget, ReturnValue) == 0x000000, "Member 'TitleScreenWidget_GetLevelSelectWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.TitleScreenWidget.GetOptionsWidget
// 0x0008 (0x0008 - 0x0000)
struct TitleScreenWidget_GetOptionsWidget final
{
public:
	class UOptionsWidget*                         ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TitleScreenWidget_GetOptionsWidget) == 0x000008, "Wrong alignment on TitleScreenWidget_GetOptionsWidget");
static_assert(sizeof(TitleScreenWidget_GetOptionsWidget) == 0x000008, "Wrong size on TitleScreenWidget_GetOptionsWidget");
static_assert(offsetof(TitleScreenWidget_GetOptionsWidget, ReturnValue) == 0x000000, "Member 'TitleScreenWidget_GetOptionsWidget::ReturnValue' has a wrong offset!");

// Function Phoenix.TraversalState.OnNodeAbilityUpdateRequested
// 0x0010 (0x0010 - 0x0000)
struct TraversalState_OnNodeAbilityUpdateRequested final
{
public:
	const class UPhxGameplayAbilityDefinition_Traverse_Fixed* AbilityDefinition;                     // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	const class AActor*                           NextNode;                                          // 0x0008(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TraversalState_OnNodeAbilityUpdateRequested) == 0x000008, "Wrong alignment on TraversalState_OnNodeAbilityUpdateRequested");
static_assert(sizeof(TraversalState_OnNodeAbilityUpdateRequested) == 0x000010, "Wrong size on TraversalState_OnNodeAbilityUpdateRequested");
static_assert(offsetof(TraversalState_OnNodeAbilityUpdateRequested, AbilityDefinition) == 0x000000, "Member 'TraversalState_OnNodeAbilityUpdateRequested::AbilityDefinition' has a wrong offset!");
static_assert(offsetof(TraversalState_OnNodeAbilityUpdateRequested, NextNode) == 0x000008, "Member 'TraversalState_OnNodeAbilityUpdateRequested::NextNode' has a wrong offset!");

// Function Phoenix.TraversalState.OnSplineActionChangeRequested
// 0x0001 (0x0001 - 0x0000)
struct TraversalState_OnSplineActionChangeRequested final
{
public:
	ESplineTraversalAction                        NewAction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TraversalState_OnSplineActionChangeRequested) == 0x000001, "Wrong alignment on TraversalState_OnSplineActionChangeRequested");
static_assert(sizeof(TraversalState_OnSplineActionChangeRequested) == 0x000001, "Wrong size on TraversalState_OnSplineActionChangeRequested");
static_assert(offsetof(TraversalState_OnSplineActionChangeRequested, NewAction) == 0x000000, "Member 'TraversalState_OnSplineActionChangeRequested::NewAction' has a wrong offset!");

// Function Phoenix.VehicleSeatComponent.GetIsOccupied
// 0x0001 (0x0001 - 0x0000)
struct VehicleSeatComponent_GetIsOccupied final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(VehicleSeatComponent_GetIsOccupied) == 0x000001, "Wrong alignment on VehicleSeatComponent_GetIsOccupied");
static_assert(sizeof(VehicleSeatComponent_GetIsOccupied) == 0x000001, "Wrong size on VehicleSeatComponent_GetIsOccupied");
static_assert(offsetof(VehicleSeatComponent_GetIsOccupied, ReturnValue) == 0x000000, "Member 'VehicleSeatComponent_GetIsOccupied::ReturnValue' has a wrong offset!");

// Function Phoenix.VehicleSeatComponent.GetCurrentViewpoint
// 0x0008 (0x0008 - 0x0000)
struct VehicleSeatComponent_GetCurrentViewpoint final
{
public:
	class UPassengerViewpointComponent*           ReturnValue;                                       // 0x0000(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(VehicleSeatComponent_GetCurrentViewpoint) == 0x000008, "Wrong alignment on VehicleSeatComponent_GetCurrentViewpoint");
static_assert(sizeof(VehicleSeatComponent_GetCurrentViewpoint) == 0x000008, "Wrong size on VehicleSeatComponent_GetCurrentViewpoint");
static_assert(offsetof(VehicleSeatComponent_GetCurrentViewpoint, ReturnValue) == 0x000000, "Member 'VehicleSeatComponent_GetCurrentViewpoint::ReturnValue' has a wrong offset!");

// Function Phoenix.WSMediaPanel.GetMediaPlayer
// 0x0008 (0x0008 - 0x0000)
struct WSMediaPanel_GetMediaPlayer final
{
public:
	class UMediaPlayer*                           ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSMediaPanel_GetMediaPlayer) == 0x000008, "Wrong alignment on WSMediaPanel_GetMediaPlayer");
static_assert(sizeof(WSMediaPanel_GetMediaPlayer) == 0x000008, "Wrong size on WSMediaPanel_GetMediaPlayer");
static_assert(offsetof(WSMediaPanel_GetMediaPlayer, ReturnValue) == 0x000000, "Member 'WSMediaPanel_GetMediaPlayer::ReturnValue' has a wrong offset!");

// Function Phoenix.WSEndScreen.GetScreenTimeElapsed
// 0x0004 (0x0004 - 0x0000)
struct WSEndScreen_GetScreenTimeElapsed final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSEndScreen_GetScreenTimeElapsed) == 0x000004, "Wrong alignment on WSEndScreen_GetScreenTimeElapsed");
static_assert(sizeof(WSEndScreen_GetScreenTimeElapsed) == 0x000004, "Wrong size on WSEndScreen_GetScreenTimeElapsed");
static_assert(offsetof(WSEndScreen_GetScreenTimeElapsed, ReturnValue) == 0x000000, "Member 'WSEndScreen_GetScreenTimeElapsed::ReturnValue' has a wrong offset!");

// Function Phoenix.WSEndScreen.GetScreenTimeRemaining
// 0x0004 (0x0004 - 0x0000)
struct WSEndScreen_GetScreenTimeRemaining final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSEndScreen_GetScreenTimeRemaining) == 0x000004, "Wrong alignment on WSEndScreen_GetScreenTimeRemaining");
static_assert(sizeof(WSEndScreen_GetScreenTimeRemaining) == 0x000004, "Wrong size on WSEndScreen_GetScreenTimeRemaining");
static_assert(offsetof(WSEndScreen_GetScreenTimeRemaining, ReturnValue) == 0x000000, "Member 'WSEndScreen_GetScreenTimeRemaining::ReturnValue' has a wrong offset!");

// Function Phoenix.WSInventoryItemUI.SetItemData
// 0x0100 (0x0100 - 0x0000)
struct WSInventoryItemUI_SetItemData final
{
public:
	struct FItemData                              InItem;                                            // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSInventoryItemUI_SetItemData) == 0x000008, "Wrong alignment on WSInventoryItemUI_SetItemData");
static_assert(sizeof(WSInventoryItemUI_SetItemData) == 0x000100, "Wrong size on WSInventoryItemUI_SetItemData");
static_assert(offsetof(WSInventoryItemUI_SetItemData, InItem) == 0x000000, "Member 'WSInventoryItemUI_SetItemData::InItem' has a wrong offset!");

// Function Phoenix.WSMenu.SetChildPanel
// 0x0008 (0x0008 - 0x0000)
struct WSMenu_SetChildPanel final
{
public:
	TSubclassOf<class AWSPanel>                   InClass;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSMenu_SetChildPanel) == 0x000008, "Wrong alignment on WSMenu_SetChildPanel");
static_assert(sizeof(WSMenu_SetChildPanel) == 0x000008, "Wrong size on WSMenu_SetChildPanel");
static_assert(offsetof(WSMenu_SetChildPanel, InClass) == 0x000000, "Member 'WSMenu_SetChildPanel::InClass' has a wrong offset!");

// Function Phoenix.WSMenu.SetNavigationVisibility
// 0x0001 (0x0001 - 0x0000)
struct WSMenu_SetNavigationVisibility final
{
public:
	bool                                          bVisible;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSMenu_SetNavigationVisibility) == 0x000001, "Wrong alignment on WSMenu_SetNavigationVisibility");
static_assert(sizeof(WSMenu_SetNavigationVisibility) == 0x000001, "Wrong size on WSMenu_SetNavigationVisibility");
static_assert(offsetof(WSMenu_SetNavigationVisibility, bVisible) == 0x000000, "Member 'WSMenu_SetNavigationVisibility::bVisible' has a wrong offset!");

// Function Phoenix.WSMenu.SetSelection
// 0x0008 (0x0008 - 0x0000)
struct WSMenu_SetSelection final
{
public:
	int32                                         SelectionIndex;                                    // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAnimate;                                          // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRightHand;                                        // 0x0005(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6[0x2];                                        // 0x0006(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WSMenu_SetSelection) == 0x000004, "Wrong alignment on WSMenu_SetSelection");
static_assert(sizeof(WSMenu_SetSelection) == 0x000008, "Wrong size on WSMenu_SetSelection");
static_assert(offsetof(WSMenu_SetSelection, SelectionIndex) == 0x000000, "Member 'WSMenu_SetSelection::SelectionIndex' has a wrong offset!");
static_assert(offsetof(WSMenu_SetSelection, bAnimate) == 0x000004, "Member 'WSMenu_SetSelection::bAnimate' has a wrong offset!");
static_assert(offsetof(WSMenu_SetSelection, bRightHand) == 0x000005, "Member 'WSMenu_SetSelection::bRightHand' has a wrong offset!");

// Function Phoenix.WSMenu.GetActiveSelectable
// 0x0008 (0x0008 - 0x0000)
struct WSMenu_GetActiveSelectable final
{
public:
	class AWSSelectable*                          ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSMenu_GetActiveSelectable) == 0x000008, "Wrong alignment on WSMenu_GetActiveSelectable");
static_assert(sizeof(WSMenu_GetActiveSelectable) == 0x000008, "Wrong size on WSMenu_GetActiveSelectable");
static_assert(offsetof(WSMenu_GetActiveSelectable, ReturnValue) == 0x000000, "Member 'WSMenu_GetActiveSelectable::ReturnValue' has a wrong offset!");

// Function Phoenix.WSMenu.GetChildPanel
// 0x0008 (0x0008 - 0x0000)
struct WSMenu_GetChildPanel final
{
public:
	class AWSPanel*                               ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSMenu_GetChildPanel) == 0x000008, "Wrong alignment on WSMenu_GetChildPanel");
static_assert(sizeof(WSMenu_GetChildPanel) == 0x000008, "Wrong size on WSMenu_GetChildPanel");
static_assert(offsetof(WSMenu_GetChildPanel, ReturnValue) == 0x000000, "Member 'WSMenu_GetChildPanel::ReturnValue' has a wrong offset!");

// Function Phoenix.WSMenu.GetSelectables
// 0x0010 (0x0010 - 0x0000)
struct WSMenu_GetSelectables final
{
public:
	TArray<class AWSSelectable*>                  ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSMenu_GetSelectables) == 0x000008, "Wrong alignment on WSMenu_GetSelectables");
static_assert(sizeof(WSMenu_GetSelectables) == 0x000010, "Wrong size on WSMenu_GetSelectables");
static_assert(offsetof(WSMenu_GetSelectables, ReturnValue) == 0x000000, "Member 'WSMenu_GetSelectables::ReturnValue' has a wrong offset!");

// Function Phoenix.WSLevelMenu.GetDemoLevelAssets
// 0x0010 (0x0010 - 0x0000)
struct WSLevelMenu_GetDemoLevelAssets final
{
public:
	TArray<class FName>                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSLevelMenu_GetDemoLevelAssets) == 0x000008, "Wrong alignment on WSLevelMenu_GetDemoLevelAssets");
static_assert(sizeof(WSLevelMenu_GetDemoLevelAssets) == 0x000010, "Wrong size on WSLevelMenu_GetDemoLevelAssets");
static_assert(offsetof(WSLevelMenu_GetDemoLevelAssets, ReturnValue) == 0x000000, "Member 'WSLevelMenu_GetDemoLevelAssets::ReturnValue' has a wrong offset!");

// Function Phoenix.WSLevelMenu.GetLevelAssets
// 0x0010 (0x0010 - 0x0000)
struct WSLevelMenu_GetLevelAssets final
{
public:
	TArray<class FName>                           ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSLevelMenu_GetLevelAssets) == 0x000008, "Wrong alignment on WSLevelMenu_GetLevelAssets");
static_assert(sizeof(WSLevelMenu_GetLevelAssets) == 0x000010, "Wrong size on WSLevelMenu_GetLevelAssets");
static_assert(offsetof(WSLevelMenu_GetLevelAssets, ReturnValue) == 0x000000, "Member 'WSLevelMenu_GetLevelAssets::ReturnValue' has a wrong offset!");

// Function Phoenix.WSLevelMenu.GetLevelTransitionAssets
// 0x0010 (0x0010 - 0x0000)
struct WSLevelMenu_GetLevelTransitionAssets final
{
public:
	TArray<class ULevelTransitionDataAsset*>      ReturnValue;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSLevelMenu_GetLevelTransitionAssets) == 0x000008, "Wrong alignment on WSLevelMenu_GetLevelTransitionAssets");
static_assert(sizeof(WSLevelMenu_GetLevelTransitionAssets) == 0x000010, "Wrong size on WSLevelMenu_GetLevelTransitionAssets");
static_assert(offsetof(WSLevelMenu_GetLevelTransitionAssets, ReturnValue) == 0x000000, "Member 'WSLevelMenu_GetLevelTransitionAssets::ReturnValue' has a wrong offset!");

// Function Phoenix.WSLockPickUI.HideUI
// 0x0001 (0x0001 - 0x0000)
struct WSLockPickUI_HideUI final
{
public:
	bool                                          bSuccess;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSLockPickUI_HideUI) == 0x000001, "Wrong alignment on WSLockPickUI_HideUI");
static_assert(sizeof(WSLockPickUI_HideUI) == 0x000001, "Wrong size on WSLockPickUI_HideUI");
static_assert(offsetof(WSLockPickUI_HideUI, bSuccess) == 0x000000, "Member 'WSLockPickUI_HideUI::bSuccess' has a wrong offset!");

// Function Phoenix.WSLockPickUI.UpdateKnobSlider
// 0x000C (0x000C - 0x0000)
struct WSLockPickUI_UpdateKnobSlider final
{
public:
	uint8                                         SliderIndex;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Value;                                             // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsSliding;                                        // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WSLockPickUI_UpdateKnobSlider) == 0x000004, "Wrong alignment on WSLockPickUI_UpdateKnobSlider");
static_assert(sizeof(WSLockPickUI_UpdateKnobSlider) == 0x00000C, "Wrong size on WSLockPickUI_UpdateKnobSlider");
static_assert(offsetof(WSLockPickUI_UpdateKnobSlider, SliderIndex) == 0x000000, "Member 'WSLockPickUI_UpdateKnobSlider::SliderIndex' has a wrong offset!");
static_assert(offsetof(WSLockPickUI_UpdateKnobSlider, Value) == 0x000004, "Member 'WSLockPickUI_UpdateKnobSlider::Value' has a wrong offset!");
static_assert(offsetof(WSLockPickUI_UpdateKnobSlider, bIsSliding) == 0x000008, "Member 'WSLockPickUI_UpdateKnobSlider::bIsSliding' has a wrong offset!");

// Function Phoenix.WSLockPickUI.UpdateKnobSolved
// 0x0002 (0x0002 - 0x0000)
struct WSLockPickUI_UpdateKnobSolved final
{
public:
	uint8                                         SliderIndex;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsSolved;                                         // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSLockPickUI_UpdateKnobSolved) == 0x000001, "Wrong alignment on WSLockPickUI_UpdateKnobSolved");
static_assert(sizeof(WSLockPickUI_UpdateKnobSolved) == 0x000002, "Wrong size on WSLockPickUI_UpdateKnobSolved");
static_assert(offsetof(WSLockPickUI_UpdateKnobSolved, SliderIndex) == 0x000000, "Member 'WSLockPickUI_UpdateKnobSolved::SliderIndex' has a wrong offset!");
static_assert(offsetof(WSLockPickUI_UpdateKnobSolved, bIsSolved) == 0x000001, "Member 'WSLockPickUI_UpdateKnobSolved::bIsSolved' has a wrong offset!");

// Function Phoenix.WSLockPickUI.UpdateSelectedKnob
// 0x0001 (0x0001 - 0x0000)
struct WSLockPickUI_UpdateSelectedKnob final
{
public:
	uint8                                         SliderIndex;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSLockPickUI_UpdateSelectedKnob) == 0x000001, "Wrong alignment on WSLockPickUI_UpdateSelectedKnob");
static_assert(sizeof(WSLockPickUI_UpdateSelectedKnob) == 0x000001, "Wrong size on WSLockPickUI_UpdateSelectedKnob");
static_assert(offsetof(WSLockPickUI_UpdateSelectedKnob, SliderIndex) == 0x000000, "Member 'WSLockPickUI_UpdateSelectedKnob::SliderIndex' has a wrong offset!");

// Function Phoenix.WSLockPickUI.UpdateTimer
// 0x0004 (0x0004 - 0x0000)
struct WSLockPickUI_UpdateTimer final
{
public:
	float                                         Value;                                             // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSLockPickUI_UpdateTimer) == 0x000004, "Wrong alignment on WSLockPickUI_UpdateTimer");
static_assert(sizeof(WSLockPickUI_UpdateTimer) == 0x000004, "Wrong size on WSLockPickUI_UpdateTimer");
static_assert(offsetof(WSLockPickUI_UpdateTimer, Value) == 0x000000, "Member 'WSLockPickUI_UpdateTimer::Value' has a wrong offset!");

// Function Phoenix.WSPrinterButton.SetAffordableVisuals
// 0x0001 (0x0001 - 0x0000)
struct WSPrinterButton_SetAffordableVisuals final
{
public:
	bool                                          bAffordable;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPrinterButton_SetAffordableVisuals) == 0x000001, "Wrong alignment on WSPrinterButton_SetAffordableVisuals");
static_assert(sizeof(WSPrinterButton_SetAffordableVisuals) == 0x000001, "Wrong size on WSPrinterButton_SetAffordableVisuals");
static_assert(offsetof(WSPrinterButton_SetAffordableVisuals, bAffordable) == 0x000000, "Member 'WSPrinterButton_SetAffordableVisuals::bAffordable' has a wrong offset!");

// Function Phoenix.WSPrinterButton.SetItemData
// 0x0100 (0x0100 - 0x0000)
struct WSPrinterButton_SetItemData final
{
public:
	struct FItemData                              InItemData;                                        // 0x0000(0x0100)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPrinterButton_SetItemData) == 0x000008, "Wrong alignment on WSPrinterButton_SetItemData");
static_assert(sizeof(WSPrinterButton_SetItemData) == 0x000100, "Wrong size on WSPrinterButton_SetItemData");
static_assert(offsetof(WSPrinterButton_SetItemData, InItemData) == 0x000000, "Member 'WSPrinterButton_SetItemData::InItemData' has a wrong offset!");

// Function Phoenix.WSPrinterButton.SetVirtualItemData
// 0x0008 (0x0008 - 0x0000)
struct WSPrinterButton_SetVirtualItemData final
{
public:
	class UVirtualItemData*                       InVID;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPrinterButton_SetVirtualItemData) == 0x000008, "Wrong alignment on WSPrinterButton_SetVirtualItemData");
static_assert(sizeof(WSPrinterButton_SetVirtualItemData) == 0x000008, "Wrong size on WSPrinterButton_SetVirtualItemData");
static_assert(offsetof(WSPrinterButton_SetVirtualItemData, InVID) == 0x000000, "Member 'WSPrinterButton_SetVirtualItemData::InVID' has a wrong offset!");

// Function Phoenix.WSPrinterUI.NotifyResizeHologram
// 0x0001 (0x0001 - 0x0000)
struct WSPrinterUI_NotifyResizeHologram final
{
public:
	bool                                          bBig;                                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPrinterUI_NotifyResizeHologram) == 0x000001, "Wrong alignment on WSPrinterUI_NotifyResizeHologram");
static_assert(sizeof(WSPrinterUI_NotifyResizeHologram) == 0x000001, "Wrong size on WSPrinterUI_NotifyResizeHologram");
static_assert(offsetof(WSPrinterUI_NotifyResizeHologram, bBig) == 0x000000, "Member 'WSPrinterUI_NotifyResizeHologram::bBig' has a wrong offset!");

// Function Phoenix.WSPrinterUI.GetSelected
// 0x0008 (0x0008 - 0x0000)
struct WSPrinterUI_GetSelected final
{
public:
	class AWSPrinterButton*                       ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSPrinterUI_GetSelected) == 0x000008, "Wrong alignment on WSPrinterUI_GetSelected");
static_assert(sizeof(WSPrinterUI_GetSelected) == 0x000008, "Wrong size on WSPrinterUI_GetSelected");
static_assert(offsetof(WSPrinterUI_GetSelected, ReturnValue) == 0x000000, "Member 'WSPrinterUI_GetSelected::ReturnValue' has a wrong offset!");

// Function Phoenix.WSRecipeButton.GetRecipe
// 0x0008 (0x0008 - 0x0000)
struct WSRecipeButton_GetRecipe final
{
public:
	class UPhxCraftingRecipe*                     ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSRecipeButton_GetRecipe) == 0x000008, "Wrong alignment on WSRecipeButton_GetRecipe");
static_assert(sizeof(WSRecipeButton_GetRecipe) == 0x000008, "Wrong size on WSRecipeButton_GetRecipe");
static_assert(offsetof(WSRecipeButton_GetRecipe, ReturnValue) == 0x000000, "Member 'WSRecipeButton_GetRecipe::ReturnValue' has a wrong offset!");

// Function Phoenix.WSSlider.SetLabel
// 0x0018 (0x0018 - 0x0000)
struct WSSlider_SetLabel final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSlider_SetLabel) == 0x000008, "Wrong alignment on WSSlider_SetLabel");
static_assert(sizeof(WSSlider_SetLabel) == 0x000018, "Wrong size on WSSlider_SetLabel");
static_assert(offsetof(WSSlider_SetLabel, InText) == 0x000000, "Member 'WSSlider_SetLabel::InText' has a wrong offset!");

// Function Phoenix.WSSlider.SetSliderValue
// 0x0008 (0x0008 - 0x0000)
struct WSSlider_SetSliderValue final
{
public:
	float                                         InValue;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bBroadcast;                                        // 0x0004(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WSSlider_SetSliderValue) == 0x000004, "Wrong alignment on WSSlider_SetSliderValue");
static_assert(sizeof(WSSlider_SetSliderValue) == 0x000008, "Wrong size on WSSlider_SetSliderValue");
static_assert(offsetof(WSSlider_SetSliderValue, InValue) == 0x000000, "Member 'WSSlider_SetSliderValue::InValue' has a wrong offset!");
static_assert(offsetof(WSSlider_SetSliderValue, bBroadcast) == 0x000004, "Member 'WSSlider_SetSliderValue::bBroadcast' has a wrong offset!");

// Function Phoenix.WSSubtitlesPanelUI.UpdateSubtitleText
// 0x0030 (0x0030 - 0x0000)
struct WSSubtitlesPanelUI_UpdateSubtitleText final
{
public:
	class FText                                   PrimaryText;                                       // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class FText                                   SecondaryText;                                     // 0x0018(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSSubtitlesPanelUI_UpdateSubtitleText) == 0x000008, "Wrong alignment on WSSubtitlesPanelUI_UpdateSubtitleText");
static_assert(sizeof(WSSubtitlesPanelUI_UpdateSubtitleText) == 0x000030, "Wrong size on WSSubtitlesPanelUI_UpdateSubtitleText");
static_assert(offsetof(WSSubtitlesPanelUI_UpdateSubtitleText, PrimaryText) == 0x000000, "Member 'WSSubtitlesPanelUI_UpdateSubtitleText::PrimaryText' has a wrong offset!");
static_assert(offsetof(WSSubtitlesPanelUI_UpdateSubtitleText, SecondaryText) == 0x000018, "Member 'WSSubtitlesPanelUI_UpdateSubtitleText::SecondaryText' has a wrong offset!");

// Function Phoenix.WSToggle.SetEnabled
// 0x0002 (0x0002 - 0x0000)
struct WSToggle_SetEnabled final
{
public:
	bool                                          bInEnabled;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bBroadcast;                                        // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSToggle_SetEnabled) == 0x000001, "Wrong alignment on WSToggle_SetEnabled");
static_assert(sizeof(WSToggle_SetEnabled) == 0x000002, "Wrong size on WSToggle_SetEnabled");
static_assert(offsetof(WSToggle_SetEnabled, bInEnabled) == 0x000000, "Member 'WSToggle_SetEnabled::bInEnabled' has a wrong offset!");
static_assert(offsetof(WSToggle_SetEnabled, bBroadcast) == 0x000001, "Member 'WSToggle_SetEnabled::bBroadcast' has a wrong offset!");

// Function Phoenix.WSToggle.SetLabel
// 0x0018 (0x0018 - 0x0000)
struct WSToggle_SetLabel final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSToggle_SetLabel) == 0x000008, "Wrong alignment on WSToggle_SetLabel");
static_assert(sizeof(WSToggle_SetLabel) == 0x000018, "Wrong size on WSToggle_SetLabel");
static_assert(offsetof(WSToggle_SetLabel, InText) == 0x000000, "Member 'WSToggle_SetLabel::InText' has a wrong offset!");

// Function Phoenix.WSToggle.IsEnabled
// 0x0001 (0x0001 - 0x0000)
struct WSToggle_IsEnabled final
{
public:
	bool                                          ReturnValue;                                       // 0x0000(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WSToggle_IsEnabled) == 0x000001, "Wrong alignment on WSToggle_IsEnabled");
static_assert(sizeof(WSToggle_IsEnabled) == 0x000001, "Wrong size on WSToggle_IsEnabled");
static_assert(offsetof(WSToggle_IsEnabled, ReturnValue) == 0x000000, "Member 'WSToggle_IsEnabled::ReturnValue' has a wrong offset!");

}

