#pragma once

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

// Package: CommonUI

#include "Basic.hpp"

#include "Engine_structs.hpp"
#include "SlateCore_structs.hpp"
#include "CommonUI_structs.hpp"
#include "CommonInput_structs.hpp"
#include "CoreUObject_structs.hpp"
#include "UMG_structs.hpp"


namespace SDK::Params
{

// Function CommonUI.CommonBorder.SetStyle
// 0x0008 (0x0008 - 0x0000)
struct CommonBorder_SetStyle final
{
public:
	TSubclassOf<class UCommonBorderStyle>         InStyle;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonBorder_SetStyle) == 0x000008, "Wrong alignment on CommonBorder_SetStyle");
static_assert(sizeof(CommonBorder_SetStyle) == 0x000008, "Wrong size on CommonBorder_SetStyle");
static_assert(offsetof(CommonBorder_SetStyle, InStyle) == 0x000000, "Member 'CommonBorder_SetStyle::InStyle' has a wrong offset!");

// DelegateFunction CommonUI.CommonActionWidget.OnInputMethodChanged__DelegateSignature
// 0x0001 (0x0001 - 0x0000)
struct CommonActionWidget_OnInputMethodChanged__DelegateSignature final
{
public:
	bool                                          bUsingGamepad;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActionWidget_OnInputMethodChanged__DelegateSignature) == 0x000001, "Wrong alignment on CommonActionWidget_OnInputMethodChanged__DelegateSignature");
static_assert(sizeof(CommonActionWidget_OnInputMethodChanged__DelegateSignature) == 0x000001, "Wrong size on CommonActionWidget_OnInputMethodChanged__DelegateSignature");
static_assert(offsetof(CommonActionWidget_OnInputMethodChanged__DelegateSignature, bUsingGamepad) == 0x000000, "Member 'CommonActionWidget_OnInputMethodChanged__DelegateSignature::bUsingGamepad' has a wrong offset!");

// Function CommonUI.CommonActionWidget.SetIconRimBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonActionWidget_SetIconRimBrush final
{
public:
	struct FSlateBrush                            InIconRimBrush;                                    // 0x0000(0x0088)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActionWidget_SetIconRimBrush) == 0x000008, "Wrong alignment on CommonActionWidget_SetIconRimBrush");
static_assert(sizeof(CommonActionWidget_SetIconRimBrush) == 0x000088, "Wrong size on CommonActionWidget_SetIconRimBrush");
static_assert(offsetof(CommonActionWidget_SetIconRimBrush, InIconRimBrush) == 0x000000, "Member 'CommonActionWidget_SetIconRimBrush::InIconRimBrush' has a wrong offset!");

// Function CommonUI.CommonActionWidget.SetInputAction
// 0x0010 (0x0010 - 0x0000)
struct CommonActionWidget_SetInputAction final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActionWidget_SetInputAction) == 0x000008, "Wrong alignment on CommonActionWidget_SetInputAction");
static_assert(sizeof(CommonActionWidget_SetInputAction) == 0x000010, "Wrong size on CommonActionWidget_SetInputAction");
static_assert(offsetof(CommonActionWidget_SetInputAction, InputActionRow) == 0x000000, "Member 'CommonActionWidget_SetInputAction::InputActionRow' has a wrong offset!");

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

// Function CommonUI.CommonActionWidget.GetIcon
// 0x0088 (0x0088 - 0x0000)
struct CommonActionWidget_GetIcon final
{
public:
	struct FSlateBrush                            ReturnValue;                                       // 0x0000(0x0088)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActionWidget_GetIcon) == 0x000008, "Wrong alignment on CommonActionWidget_GetIcon");
static_assert(sizeof(CommonActionWidget_GetIcon) == 0x000088, "Wrong size on CommonActionWidget_GetIcon");
static_assert(offsetof(CommonActionWidget_GetIcon, ReturnValue) == 0x000000, "Member 'CommonActionWidget_GetIcon::ReturnValue' has a wrong offset!");

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

// Function CommonUI.CommonUserWidget.OnTouchLeave
// 0x0070 (0x0070 - 0x0000)
struct CommonUserWidget_OnTouchLeave final
{
public:
	struct FPointerEvent                          TouchEvent;                                        // 0x0000(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonUserWidget_OnTouchLeave) == 0x000008, "Wrong alignment on CommonUserWidget_OnTouchLeave");
static_assert(sizeof(CommonUserWidget_OnTouchLeave) == 0x000070, "Wrong size on CommonUserWidget_OnTouchLeave");
static_assert(offsetof(CommonUserWidget_OnTouchLeave, TouchEvent) == 0x000000, "Member 'CommonUserWidget_OnTouchLeave::TouchEvent' has a wrong offset!");

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

// Function CommonUI.CommonActivatablePanel.AddInputActionHandler
// 0x0020 (0x0020 - 0x0000)
struct CommonActivatablePanel_AddInputActionHandler final
{
public:
	class UDataTable*                             DataTable;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   RowName;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(bool* bPassThrough)>           CommitedEvent;                                     // 0x0010(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_AddInputActionHandler) == 0x000008, "Wrong alignment on CommonActivatablePanel_AddInputActionHandler");
static_assert(sizeof(CommonActivatablePanel_AddInputActionHandler) == 0x000020, "Wrong size on CommonActivatablePanel_AddInputActionHandler");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandler, DataTable) == 0x000000, "Member 'CommonActivatablePanel_AddInputActionHandler::DataTable' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandler, RowName) == 0x000008, "Member 'CommonActivatablePanel_AddInputActionHandler::RowName' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandler, CommitedEvent) == 0x000010, "Member 'CommonActivatablePanel_AddInputActionHandler::CommitedEvent' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.AddInputActionHandlerWithPopup
// 0x0028 (0x0028 - 0x0000)
struct CommonActivatablePanel_AddInputActionHandlerWithPopup final
{
public:
	class UDataTable*                             DataTable;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   RowName;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(bool* bPassThrough)>           CommitedEvent;                                     // 0x0010(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	class UCommonPopupMenu*                       PopupMenu;                                         // 0x0020(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_AddInputActionHandlerWithPopup) == 0x000008, "Wrong alignment on CommonActivatablePanel_AddInputActionHandlerWithPopup");
static_assert(sizeof(CommonActivatablePanel_AddInputActionHandlerWithPopup) == 0x000028, "Wrong size on CommonActivatablePanel_AddInputActionHandlerWithPopup");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithPopup, DataTable) == 0x000000, "Member 'CommonActivatablePanel_AddInputActionHandlerWithPopup::DataTable' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithPopup, RowName) == 0x000008, "Member 'CommonActivatablePanel_AddInputActionHandlerWithPopup::RowName' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithPopup, CommitedEvent) == 0x000010, "Member 'CommonActivatablePanel_AddInputActionHandlerWithPopup::CommitedEvent' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithPopup, PopupMenu) == 0x000020, "Member 'CommonActivatablePanel_AddInputActionHandlerWithPopup::PopupMenu' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.AddInputActionHandlerWithProgress
// 0x0030 (0x0030 - 0x0000)
struct CommonActivatablePanel_AddInputActionHandlerWithProgress final
{
public:
	class UDataTable*                             DataTable;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   RowName;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(bool* bPassThrough)>           CommitedEvent;                                     // 0x0010(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(float HeldPercent)>            ProgressEvent;                                     // 0x0020(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_AddInputActionHandlerWithProgress) == 0x000008, "Wrong alignment on CommonActivatablePanel_AddInputActionHandlerWithProgress");
static_assert(sizeof(CommonActivatablePanel_AddInputActionHandlerWithProgress) == 0x000030, "Wrong size on CommonActivatablePanel_AddInputActionHandlerWithProgress");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithProgress, DataTable) == 0x000000, "Member 'CommonActivatablePanel_AddInputActionHandlerWithProgress::DataTable' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithProgress, RowName) == 0x000008, "Member 'CommonActivatablePanel_AddInputActionHandlerWithProgress::RowName' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithProgress, CommitedEvent) == 0x000010, "Member 'CommonActivatablePanel_AddInputActionHandlerWithProgress::CommitedEvent' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithProgress, ProgressEvent) == 0x000020, "Member 'CommonActivatablePanel_AddInputActionHandlerWithProgress::ProgressEvent' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.AddInputActionHandlerWithProgressPopup
// 0x0038 (0x0038 - 0x0000)
struct CommonActivatablePanel_AddInputActionHandlerWithProgressPopup final
{
public:
	class UDataTable*                             DataTable;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   RowName;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(bool* bPassThrough)>           CommitedEvent;                                     // 0x0010(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(float HeldPercent)>            ProgressEvent;                                     // 0x0020(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	class UCommonPopupMenu*                       PopupMenu;                                         // 0x0030(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_AddInputActionHandlerWithProgressPopup) == 0x000008, "Wrong alignment on CommonActivatablePanel_AddInputActionHandlerWithProgressPopup");
static_assert(sizeof(CommonActivatablePanel_AddInputActionHandlerWithProgressPopup) == 0x000038, "Wrong size on CommonActivatablePanel_AddInputActionHandlerWithProgressPopup");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithProgressPopup, DataTable) == 0x000000, "Member 'CommonActivatablePanel_AddInputActionHandlerWithProgressPopup::DataTable' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithProgressPopup, RowName) == 0x000008, "Member 'CommonActivatablePanel_AddInputActionHandlerWithProgressPopup::RowName' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithProgressPopup, CommitedEvent) == 0x000010, "Member 'CommonActivatablePanel_AddInputActionHandlerWithProgressPopup::CommitedEvent' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithProgressPopup, ProgressEvent) == 0x000020, "Member 'CommonActivatablePanel_AddInputActionHandlerWithProgressPopup::ProgressEvent' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionHandlerWithProgressPopup, PopupMenu) == 0x000030, "Member 'CommonActivatablePanel_AddInputActionHandlerWithProgressPopup::PopupMenu' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.AddInputActionNoHandler
// 0x0010 (0x0010 - 0x0000)
struct CommonActivatablePanel_AddInputActionNoHandler final
{
public:
	class UDataTable*                             DataTable;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   RowName;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_AddInputActionNoHandler) == 0x000008, "Wrong alignment on CommonActivatablePanel_AddInputActionNoHandler");
static_assert(sizeof(CommonActivatablePanel_AddInputActionNoHandler) == 0x000010, "Wrong size on CommonActivatablePanel_AddInputActionNoHandler");
static_assert(offsetof(CommonActivatablePanel_AddInputActionNoHandler, DataTable) == 0x000000, "Member 'CommonActivatablePanel_AddInputActionNoHandler::DataTable' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_AddInputActionNoHandler, RowName) == 0x000008, "Member 'CommonActivatablePanel_AddInputActionNoHandler::RowName' has a wrong offset!");

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

// Function CommonUI.CommonActivatablePanel.RemoveInputActionHandler
// 0x0010 (0x0010 - 0x0000)
struct CommonActivatablePanel_RemoveInputActionHandler final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_RemoveInputActionHandler) == 0x000008, "Wrong alignment on CommonActivatablePanel_RemoveInputActionHandler");
static_assert(sizeof(CommonActivatablePanel_RemoveInputActionHandler) == 0x000010, "Wrong size on CommonActivatablePanel_RemoveInputActionHandler");
static_assert(offsetof(CommonActivatablePanel_RemoveInputActionHandler, InputActionRow) == 0x000000, "Member 'CommonActivatablePanel_RemoveInputActionHandler::InputActionRow' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.SetActionHandlerState
// 0x0018 (0x0018 - 0x0000)
struct CommonActivatablePanel_SetActionHandlerState final
{
public:
	const class UDataTable*                       DataTable;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   RowName;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputActionState                             State;                                             // 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(CommonActivatablePanel_SetActionHandlerState) == 0x000008, "Wrong alignment on CommonActivatablePanel_SetActionHandlerState");
static_assert(sizeof(CommonActivatablePanel_SetActionHandlerState) == 0x000018, "Wrong size on CommonActivatablePanel_SetActionHandlerState");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerState, DataTable) == 0x000000, "Member 'CommonActivatablePanel_SetActionHandlerState::DataTable' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerState, RowName) == 0x000008, "Member 'CommonActivatablePanel_SetActionHandlerState::RowName' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerState, State) == 0x000010, "Member 'CommonActivatablePanel_SetActionHandlerState::State' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.SetActionHandlerStateFromHandle
// 0x0018 (0x0018 - 0x0000)
struct CommonActivatablePanel_SetActionHandlerStateFromHandle final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	EInputActionState                             State;                                             // 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(CommonActivatablePanel_SetActionHandlerStateFromHandle) == 0x000008, "Wrong alignment on CommonActivatablePanel_SetActionHandlerStateFromHandle");
static_assert(sizeof(CommonActivatablePanel_SetActionHandlerStateFromHandle) == 0x000018, "Wrong size on CommonActivatablePanel_SetActionHandlerStateFromHandle");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerStateFromHandle, InputActionRow) == 0x000000, "Member 'CommonActivatablePanel_SetActionHandlerStateFromHandle::InputActionRow' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerStateFromHandle, State) == 0x000010, "Member 'CommonActivatablePanel_SetActionHandlerStateFromHandle::State' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.SetActionHandlerStateFromHandleWithDisabledCommitEvent
// 0x0028 (0x0028 - 0x0000)
struct CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	EInputActionState                             State;                                             // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x3];                                       // 0x0011(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(bool* bPassThrough)>           DisabledCommitEvent;                               // 0x0014(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent) == 0x000008, "Wrong alignment on CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent");
static_assert(sizeof(CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent) == 0x000028, "Wrong size on CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent, InputActionRow) == 0x000000, "Member 'CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent::InputActionRow' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent, State) == 0x000010, "Member 'CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent::State' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent, DisabledCommitEvent) == 0x000014, "Member 'CommonActivatablePanel_SetActionHandlerStateFromHandleWithDisabledCommitEvent::DisabledCommitEvent' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.SetActionHandlerStateWithDisabledCommitEvent
// 0x0028 (0x0028 - 0x0000)
struct CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent final
{
public:
	class UDataTable*                             DataTable;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   RowName;                                           // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputActionState                             State;                                             // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x3];                                       // 0x0011(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(bool* bPassThrough)>           DisabledCommitEvent;                               // 0x0014(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent) == 0x000008, "Wrong alignment on CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent");
static_assert(sizeof(CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent) == 0x000028, "Wrong size on CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent, DataTable) == 0x000000, "Member 'CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent::DataTable' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent, RowName) == 0x000008, "Member 'CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent::RowName' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent, State) == 0x000010, "Member 'CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent::State' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent, DisabledCommitEvent) == 0x000014, "Member 'CommonActivatablePanel_SetActionHandlerStateWithDisabledCommitEvent::DisabledCommitEvent' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.SetInputActionHandler
// 0x0020 (0x0020 - 0x0000)
struct CommonActivatablePanel_SetInputActionHandler final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(bool* bPassThrough)>           CommitedEvent;                                     // 0x0010(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_SetInputActionHandler) == 0x000008, "Wrong alignment on CommonActivatablePanel_SetInputActionHandler");
static_assert(sizeof(CommonActivatablePanel_SetInputActionHandler) == 0x000020, "Wrong size on CommonActivatablePanel_SetInputActionHandler");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandler, InputActionRow) == 0x000000, "Member 'CommonActivatablePanel_SetInputActionHandler::InputActionRow' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandler, CommitedEvent) == 0x000010, "Member 'CommonActivatablePanel_SetInputActionHandler::CommitedEvent' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.SetInputActionHandlerWithPopupMenu
// 0x0028 (0x0028 - 0x0000)
struct CommonActivatablePanel_SetInputActionHandlerWithPopupMenu final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(bool* bPassThrough)>           CommitedEvent;                                     // 0x0010(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	class UCommonPopupMenu*                       PopupMenu;                                         // 0x0020(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_SetInputActionHandlerWithPopupMenu) == 0x000008, "Wrong alignment on CommonActivatablePanel_SetInputActionHandlerWithPopupMenu");
static_assert(sizeof(CommonActivatablePanel_SetInputActionHandlerWithPopupMenu) == 0x000028, "Wrong size on CommonActivatablePanel_SetInputActionHandlerWithPopupMenu");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithPopupMenu, InputActionRow) == 0x000000, "Member 'CommonActivatablePanel_SetInputActionHandlerWithPopupMenu::InputActionRow' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithPopupMenu, CommitedEvent) == 0x000010, "Member 'CommonActivatablePanel_SetInputActionHandlerWithPopupMenu::CommitedEvent' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithPopupMenu, PopupMenu) == 0x000020, "Member 'CommonActivatablePanel_SetInputActionHandlerWithPopupMenu::PopupMenu' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.SetInputActionHandlerWithProgress
// 0x0030 (0x0030 - 0x0000)
struct CommonActivatablePanel_SetInputActionHandlerWithProgress final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(bool* bPassThrough)>           CommitedEvent;                                     // 0x0010(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(float HeldPercent)>            ProgressEvent;                                     // 0x0020(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_SetInputActionHandlerWithProgress) == 0x000008, "Wrong alignment on CommonActivatablePanel_SetInputActionHandlerWithProgress");
static_assert(sizeof(CommonActivatablePanel_SetInputActionHandlerWithProgress) == 0x000030, "Wrong size on CommonActivatablePanel_SetInputActionHandlerWithProgress");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithProgress, InputActionRow) == 0x000000, "Member 'CommonActivatablePanel_SetInputActionHandlerWithProgress::InputActionRow' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithProgress, CommitedEvent) == 0x000010, "Member 'CommonActivatablePanel_SetInputActionHandlerWithProgress::CommitedEvent' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithProgress, ProgressEvent) == 0x000020, "Member 'CommonActivatablePanel_SetInputActionHandlerWithProgress::ProgressEvent' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.SetInputActionHandlerWithProgressPopupMenu
// 0x0038 (0x0038 - 0x0000)
struct CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(bool* bPassThrough)>           CommitedEvent;                                     // 0x0010(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(float HeldPercent)>            ProgressEvent;                                     // 0x0020(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	class UCommonPopupMenu*                       PopupMenu;                                         // 0x0030(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu) == 0x000008, "Wrong alignment on CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu");
static_assert(sizeof(CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu) == 0x000038, "Wrong size on CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu, InputActionRow) == 0x000000, "Member 'CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu::InputActionRow' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu, CommitedEvent) == 0x000010, "Member 'CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu::CommitedEvent' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu, ProgressEvent) == 0x000020, "Member 'CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu::ProgressEvent' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu, PopupMenu) == 0x000030, "Member 'CommonActivatablePanel_SetInputActionHandlerWithProgressPopupMenu::PopupMenu' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.GetInputActions
// 0x0018 (0x0018 - 0x0000)
struct CommonActivatablePanel_GetInputActions final
{
public:
	TArray<struct FCommonInputActionHandlerData>  InputActionDataRows;                               // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, 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(CommonActivatablePanel_GetInputActions) == 0x000008, "Wrong alignment on CommonActivatablePanel_GetInputActions");
static_assert(sizeof(CommonActivatablePanel_GetInputActions) == 0x000018, "Wrong size on CommonActivatablePanel_GetInputActions");
static_assert(offsetof(CommonActivatablePanel_GetInputActions, InputActionDataRows) == 0x000000, "Member 'CommonActivatablePanel_GetInputActions::InputActionDataRows' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_GetInputActions, ReturnValue) == 0x000010, "Member 'CommonActivatablePanel_GetInputActions::ReturnValue' has a wrong offset!");

// Function CommonUI.CommonActivatablePanel.HasInputActionHandler
// 0x0018 (0x0018 - 0x0000)
struct CommonActivatablePanel_HasInputActionHandler final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, 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(CommonActivatablePanel_HasInputActionHandler) == 0x000008, "Wrong alignment on CommonActivatablePanel_HasInputActionHandler");
static_assert(sizeof(CommonActivatablePanel_HasInputActionHandler) == 0x000018, "Wrong size on CommonActivatablePanel_HasInputActionHandler");
static_assert(offsetof(CommonActivatablePanel_HasInputActionHandler, InputActionRow) == 0x000000, "Member 'CommonActivatablePanel_HasInputActionHandler::InputActionRow' has a wrong offset!");
static_assert(offsetof(CommonActivatablePanel_HasInputActionHandler, ReturnValue) == 0x000010, "Member 'CommonActivatablePanel_HasInputActionHandler::ReturnValue' has a wrong offset!");

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

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

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

// Function CommonUI.CommonBorderStyle.GetBackgroundBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonBorderStyle_GetBackgroundBrush final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonBorderStyle_GetBackgroundBrush) == 0x000008, "Wrong alignment on CommonBorderStyle_GetBackgroundBrush");
static_assert(sizeof(CommonBorderStyle_GetBackgroundBrush) == 0x000088, "Wrong size on CommonBorderStyle_GetBackgroundBrush");
static_assert(offsetof(CommonBorderStyle_GetBackgroundBrush, Brush) == 0x000000, "Member 'CommonBorderStyle_GetBackgroundBrush::Brush' has a wrong offset!");

// Function CommonUI.CommonButtonStyle.GetButtonPadding
// 0x0010 (0x0010 - 0x0000)
struct CommonButtonStyle_GetButtonPadding final
{
public:
	struct FMargin                                OutButtonPadding;                                  // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetButtonPadding) == 0x000004, "Wrong alignment on CommonButtonStyle_GetButtonPadding");
static_assert(sizeof(CommonButtonStyle_GetButtonPadding) == 0x000010, "Wrong size on CommonButtonStyle_GetButtonPadding");
static_assert(offsetof(CommonButtonStyle_GetButtonPadding, OutButtonPadding) == 0x000000, "Member 'CommonButtonStyle_GetButtonPadding::OutButtonPadding' has a wrong offset!");

// Function CommonUI.CommonButtonStyle.GetCustomPadding
// 0x0010 (0x0010 - 0x0000)
struct CommonButtonStyle_GetCustomPadding final
{
public:
	struct FMargin                                OutCustomPadding;                                  // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetCustomPadding) == 0x000004, "Wrong alignment on CommonButtonStyle_GetCustomPadding");
static_assert(sizeof(CommonButtonStyle_GetCustomPadding) == 0x000010, "Wrong size on CommonButtonStyle_GetCustomPadding");
static_assert(offsetof(CommonButtonStyle_GetCustomPadding, OutCustomPadding) == 0x000000, "Member 'CommonButtonStyle_GetCustomPadding::OutCustomPadding' has a wrong offset!");

// Function CommonUI.CommonButtonStyle.GetDisabledBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonButtonStyle_GetDisabledBrush final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetDisabledBrush) == 0x000008, "Wrong alignment on CommonButtonStyle_GetDisabledBrush");
static_assert(sizeof(CommonButtonStyle_GetDisabledBrush) == 0x000088, "Wrong size on CommonButtonStyle_GetDisabledBrush");
static_assert(offsetof(CommonButtonStyle_GetDisabledBrush, Brush) == 0x000000, "Member 'CommonButtonStyle_GetDisabledBrush::Brush' has a wrong offset!");

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

// Function CommonUI.CommonButtonStyle.GetMaterialBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonButtonStyle_GetMaterialBrush final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetMaterialBrush) == 0x000008, "Wrong alignment on CommonButtonStyle_GetMaterialBrush");
static_assert(sizeof(CommonButtonStyle_GetMaterialBrush) == 0x000088, "Wrong size on CommonButtonStyle_GetMaterialBrush");
static_assert(offsetof(CommonButtonStyle_GetMaterialBrush, Brush) == 0x000000, "Member 'CommonButtonStyle_GetMaterialBrush::Brush' has a wrong offset!");

// Function CommonUI.CommonButtonStyle.GetNormalBaseBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonButtonStyle_GetNormalBaseBrush final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetNormalBaseBrush) == 0x000008, "Wrong alignment on CommonButtonStyle_GetNormalBaseBrush");
static_assert(sizeof(CommonButtonStyle_GetNormalBaseBrush) == 0x000088, "Wrong size on CommonButtonStyle_GetNormalBaseBrush");
static_assert(offsetof(CommonButtonStyle_GetNormalBaseBrush, Brush) == 0x000000, "Member 'CommonButtonStyle_GetNormalBaseBrush::Brush' has a wrong offset!");

// Function CommonUI.CommonButtonStyle.GetNormalHoveredBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonButtonStyle_GetNormalHoveredBrush final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetNormalHoveredBrush) == 0x000008, "Wrong alignment on CommonButtonStyle_GetNormalHoveredBrush");
static_assert(sizeof(CommonButtonStyle_GetNormalHoveredBrush) == 0x000088, "Wrong size on CommonButtonStyle_GetNormalHoveredBrush");
static_assert(offsetof(CommonButtonStyle_GetNormalHoveredBrush, Brush) == 0x000000, "Member 'CommonButtonStyle_GetNormalHoveredBrush::Brush' has a wrong offset!");

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

// Function CommonUI.CommonButtonStyle.GetNormalPressedBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonButtonStyle_GetNormalPressedBrush final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetNormalPressedBrush) == 0x000008, "Wrong alignment on CommonButtonStyle_GetNormalPressedBrush");
static_assert(sizeof(CommonButtonStyle_GetNormalPressedBrush) == 0x000088, "Wrong size on CommonButtonStyle_GetNormalPressedBrush");
static_assert(offsetof(CommonButtonStyle_GetNormalPressedBrush, Brush) == 0x000000, "Member 'CommonButtonStyle_GetNormalPressedBrush::Brush' has a wrong offset!");

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

// Function CommonUI.CommonButtonStyle.GetSelectedBaseBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonButtonStyle_GetSelectedBaseBrush final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetSelectedBaseBrush) == 0x000008, "Wrong alignment on CommonButtonStyle_GetSelectedBaseBrush");
static_assert(sizeof(CommonButtonStyle_GetSelectedBaseBrush) == 0x000088, "Wrong size on CommonButtonStyle_GetSelectedBaseBrush");
static_assert(offsetof(CommonButtonStyle_GetSelectedBaseBrush, Brush) == 0x000000, "Member 'CommonButtonStyle_GetSelectedBaseBrush::Brush' has a wrong offset!");

// Function CommonUI.CommonButtonStyle.GetSelectedHoveredBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonButtonStyle_GetSelectedHoveredBrush final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetSelectedHoveredBrush) == 0x000008, "Wrong alignment on CommonButtonStyle_GetSelectedHoveredBrush");
static_assert(sizeof(CommonButtonStyle_GetSelectedHoveredBrush) == 0x000088, "Wrong size on CommonButtonStyle_GetSelectedHoveredBrush");
static_assert(offsetof(CommonButtonStyle_GetSelectedHoveredBrush, Brush) == 0x000000, "Member 'CommonButtonStyle_GetSelectedHoveredBrush::Brush' has a wrong offset!");

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

// Function CommonUI.CommonButtonStyle.GetSelectedPressedBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonButtonStyle_GetSelectedPressedBrush final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonStyle_GetSelectedPressedBrush) == 0x000008, "Wrong alignment on CommonButtonStyle_GetSelectedPressedBrush");
static_assert(sizeof(CommonButtonStyle_GetSelectedPressedBrush) == 0x000088, "Wrong size on CommonButtonStyle_GetSelectedPressedBrush");
static_assert(offsetof(CommonButtonStyle_GetSelectedPressedBrush, Brush) == 0x000000, "Member 'CommonButtonStyle_GetSelectedPressedBrush::Brush' has a wrong offset!");

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

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

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

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

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

// Function CommonUI.CommonButton.OnInputMethodChanged
// 0x0001 (0x0001 - 0x0000)
struct CommonButton_OnInputMethodChanged final
{
public:
	ECommonInputType                              CurrentInputType;                                  // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_OnInputMethodChanged) == 0x000001, "Wrong alignment on CommonButton_OnInputMethodChanged");
static_assert(sizeof(CommonButton_OnInputMethodChanged) == 0x000001, "Wrong size on CommonButton_OnInputMethodChanged");
static_assert(offsetof(CommonButton_OnInputMethodChanged, CurrentInputType) == 0x000000, "Member 'CommonButton_OnInputMethodChanged::CurrentInputType' has a wrong offset!");

// Function CommonUI.CommonButton.OnTriggeredInputActionChanged
// 0x0010 (0x0010 - 0x0000)
struct CommonButton_OnTriggeredInputActionChanged final
{
public:
	struct FDataTableRowHandle                    NewTriggeredAction;                                // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_OnTriggeredInputActionChanged) == 0x000008, "Wrong alignment on CommonButton_OnTriggeredInputActionChanged");
static_assert(sizeof(CommonButton_OnTriggeredInputActionChanged) == 0x000010, "Wrong size on CommonButton_OnTriggeredInputActionChanged");
static_assert(offsetof(CommonButton_OnTriggeredInputActionChanged, NewTriggeredAction) == 0x000000, "Member 'CommonButton_OnTriggeredInputActionChanged::NewTriggeredAction' has a wrong offset!");

// Function CommonUI.CommonButton.SetClickMethod
// 0x0001 (0x0001 - 0x0000)
struct CommonButton_SetClickMethod final
{
public:
	EButtonClickMethod                            InClickMethod;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetClickMethod) == 0x000001, "Wrong alignment on CommonButton_SetClickMethod");
static_assert(sizeof(CommonButton_SetClickMethod) == 0x000001, "Wrong size on CommonButton_SetClickMethod");
static_assert(offsetof(CommonButton_SetClickMethod, InClickMethod) == 0x000000, "Member 'CommonButton_SetClickMethod::InClickMethod' has a wrong offset!");

// Function CommonUI.CommonButton.SetInputActionProgressMaterial
// 0x0090 (0x0090 - 0x0000)
struct CommonButton_SetInputActionProgressMaterial final
{
public:
	struct FSlateBrush                            InProgressMaterialBrush;                           // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class FName                                   InProgressMaterialParam;                           // 0x0088(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetInputActionProgressMaterial) == 0x000008, "Wrong alignment on CommonButton_SetInputActionProgressMaterial");
static_assert(sizeof(CommonButton_SetInputActionProgressMaterial) == 0x000090, "Wrong size on CommonButton_SetInputActionProgressMaterial");
static_assert(offsetof(CommonButton_SetInputActionProgressMaterial, InProgressMaterialBrush) == 0x000000, "Member 'CommonButton_SetInputActionProgressMaterial::InProgressMaterialBrush' has a wrong offset!");
static_assert(offsetof(CommonButton_SetInputActionProgressMaterial, InProgressMaterialParam) == 0x000088, "Member 'CommonButton_SetInputActionProgressMaterial::InProgressMaterialParam' has a wrong offset!");

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

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

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

// Function CommonUI.CommonButton.SetIsSelected
// 0x0002 (0x0002 - 0x0000)
struct CommonButton_SetIsSelected final
{
public:
	bool                                          InSelected;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bGiveClickFeedback;                                // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetIsSelected) == 0x000001, "Wrong alignment on CommonButton_SetIsSelected");
static_assert(sizeof(CommonButton_SetIsSelected) == 0x000002, "Wrong size on CommonButton_SetIsSelected");
static_assert(offsetof(CommonButton_SetIsSelected, InSelected) == 0x000000, "Member 'CommonButton_SetIsSelected::InSelected' has a wrong offset!");
static_assert(offsetof(CommonButton_SetIsSelected, bGiveClickFeedback) == 0x000001, "Member 'CommonButton_SetIsSelected::bGiveClickFeedback' has a wrong offset!");

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

// Function CommonUI.CommonButton.SetMinDimensions
// 0x0008 (0x0008 - 0x0000)
struct CommonButton_SetMinDimensions final
{
public:
	int32                                         InMinWidth;                                        // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InMinHeight;                                       // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetMinDimensions) == 0x000004, "Wrong alignment on CommonButton_SetMinDimensions");
static_assert(sizeof(CommonButton_SetMinDimensions) == 0x000008, "Wrong size on CommonButton_SetMinDimensions");
static_assert(offsetof(CommonButton_SetMinDimensions, InMinWidth) == 0x000000, "Member 'CommonButton_SetMinDimensions::InMinWidth' has a wrong offset!");
static_assert(offsetof(CommonButton_SetMinDimensions, InMinHeight) == 0x000004, "Member 'CommonButton_SetMinDimensions::InMinHeight' has a wrong offset!");

// Function CommonUI.CommonButton.SetPressMethod
// 0x0001 (0x0001 - 0x0000)
struct CommonButton_SetPressMethod final
{
public:
	EButtonPressMethod                            InPressMethod;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetPressMethod) == 0x000001, "Wrong alignment on CommonButton_SetPressMethod");
static_assert(sizeof(CommonButton_SetPressMethod) == 0x000001, "Wrong size on CommonButton_SetPressMethod");
static_assert(offsetof(CommonButton_SetPressMethod, InPressMethod) == 0x000000, "Member 'CommonButton_SetPressMethod::InPressMethod' has a wrong offset!");

// Function CommonUI.CommonButton.SetSelectedInternal
// 0x0003 (0x0003 - 0x0000)
struct CommonButton_SetSelectedInternal final
{
public:
	bool                                          bInSelected;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowSound;                                       // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bBroadcast;                                        // 0x0002(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetSelectedInternal) == 0x000001, "Wrong alignment on CommonButton_SetSelectedInternal");
static_assert(sizeof(CommonButton_SetSelectedInternal) == 0x000003, "Wrong size on CommonButton_SetSelectedInternal");
static_assert(offsetof(CommonButton_SetSelectedInternal, bInSelected) == 0x000000, "Member 'CommonButton_SetSelectedInternal::bInSelected' has a wrong offset!");
static_assert(offsetof(CommonButton_SetSelectedInternal, bAllowSound) == 0x000001, "Member 'CommonButton_SetSelectedInternal::bAllowSound' has a wrong offset!");
static_assert(offsetof(CommonButton_SetSelectedInternal, bBroadcast) == 0x000002, "Member 'CommonButton_SetSelectedInternal::bBroadcast' has a wrong offset!");

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

// Function CommonUI.CommonButton.SetStyle
// 0x0008 (0x0008 - 0x0000)
struct CommonButton_SetStyle final
{
public:
	TSubclassOf<class UCommonButtonStyle>         InStyle;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetStyle) == 0x000008, "Wrong alignment on CommonButton_SetStyle");
static_assert(sizeof(CommonButton_SetStyle) == 0x000008, "Wrong size on CommonButton_SetStyle");
static_assert(offsetof(CommonButton_SetStyle, InStyle) == 0x000000, "Member 'CommonButton_SetStyle::InStyle' has a wrong offset!");

// Function CommonUI.CommonButton.SetTouchMethod
// 0x0001 (0x0001 - 0x0000)
struct CommonButton_SetTouchMethod final
{
public:
	EButtonTouchMethod                            InTouchMethod;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetTouchMethod) == 0x000001, "Wrong alignment on CommonButton_SetTouchMethod");
static_assert(sizeof(CommonButton_SetTouchMethod) == 0x000001, "Wrong size on CommonButton_SetTouchMethod");
static_assert(offsetof(CommonButton_SetTouchMethod, InTouchMethod) == 0x000000, "Member 'CommonButton_SetTouchMethod::InTouchMethod' has a wrong offset!");

// Function CommonUI.CommonButton.SetTriggeredInputAction
// 0x0018 (0x0018 - 0x0000)
struct CommonButton_SetTriggeredInputAction final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	class UCommonActivatablePanel*                OldPanel;                                          // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetTriggeredInputAction) == 0x000008, "Wrong alignment on CommonButton_SetTriggeredInputAction");
static_assert(sizeof(CommonButton_SetTriggeredInputAction) == 0x000018, "Wrong size on CommonButton_SetTriggeredInputAction");
static_assert(offsetof(CommonButton_SetTriggeredInputAction, InputActionRow) == 0x000000, "Member 'CommonButton_SetTriggeredInputAction::InputActionRow' has a wrong offset!");
static_assert(offsetof(CommonButton_SetTriggeredInputAction, OldPanel) == 0x000010, "Member 'CommonButton_SetTriggeredInputAction::OldPanel' has a wrong offset!");

// Function CommonUI.CommonButton.SetTriggeringInputAction
// 0x0010 (0x0010 - 0x0000)
struct CommonButton_SetTriggeringInputAction final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_SetTriggeringInputAction) == 0x000008, "Wrong alignment on CommonButton_SetTriggeringInputAction");
static_assert(sizeof(CommonButton_SetTriggeringInputAction) == 0x000010, "Wrong size on CommonButton_SetTriggeringInputAction");
static_assert(offsetof(CommonButton_SetTriggeringInputAction, InputActionRow) == 0x000000, "Member 'CommonButton_SetTriggeringInputAction::InputActionRow' has a wrong offset!");

// Function CommonUI.CommonButton.GetCurrentButtonPadding
// 0x0010 (0x0010 - 0x0000)
struct CommonButton_GetCurrentButtonPadding final
{
public:
	struct FMargin                                OutButtonPadding;                                  // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_GetCurrentButtonPadding) == 0x000004, "Wrong alignment on CommonButton_GetCurrentButtonPadding");
static_assert(sizeof(CommonButton_GetCurrentButtonPadding) == 0x000010, "Wrong size on CommonButton_GetCurrentButtonPadding");
static_assert(offsetof(CommonButton_GetCurrentButtonPadding, OutButtonPadding) == 0x000000, "Member 'CommonButton_GetCurrentButtonPadding::OutButtonPadding' has a wrong offset!");

// Function CommonUI.CommonButton.GetCurrentCustomPadding
// 0x0010 (0x0010 - 0x0000)
struct CommonButton_GetCurrentCustomPadding final
{
public:
	struct FMargin                                OutCustomPadding;                                  // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButton_GetCurrentCustomPadding) == 0x000004, "Wrong alignment on CommonButton_GetCurrentCustomPadding");
static_assert(sizeof(CommonButton_GetCurrentCustomPadding) == 0x000010, "Wrong size on CommonButton_GetCurrentCustomPadding");
static_assert(offsetof(CommonButton_GetCurrentCustomPadding, OutCustomPadding) == 0x000000, "Member 'CommonButton_GetCurrentCustomPadding::OutCustomPadding' has a wrong offset!");

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

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

// Function CommonUI.CommonButton.GetInputAction
// 0x0018 (0x0018 - 0x0000)
struct CommonButton_GetInputAction final
{
public:
	struct FDataTableRowHandle                    InputActionRow;                                    // 0x0000(0x0010)(Parm, OutParm, 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(CommonButton_GetInputAction) == 0x000008, "Wrong alignment on CommonButton_GetInputAction");
static_assert(sizeof(CommonButton_GetInputAction) == 0x000018, "Wrong size on CommonButton_GetInputAction");
static_assert(offsetof(CommonButton_GetInputAction, InputActionRow) == 0x000000, "Member 'CommonButton_GetInputAction::InputActionRow' has a wrong offset!");
static_assert(offsetof(CommonButton_GetInputAction, ReturnValue) == 0x000010, "Member 'CommonButton_GetInputAction::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

// Function CommonUI.CommonWidgetGroupBase.AddWidget
// 0x0008 (0x0008 - 0x0000)
struct CommonWidgetGroupBase_AddWidget final
{
public:
	class UWidget*                                InWidget;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonWidgetGroupBase_AddWidget) == 0x000008, "Wrong alignment on CommonWidgetGroupBase_AddWidget");
static_assert(sizeof(CommonWidgetGroupBase_AddWidget) == 0x000008, "Wrong size on CommonWidgetGroupBase_AddWidget");
static_assert(offsetof(CommonWidgetGroupBase_AddWidget, InWidget) == 0x000000, "Member 'CommonWidgetGroupBase_AddWidget::InWidget' has a wrong offset!");

// Function CommonUI.CommonWidgetGroupBase.RemoveWidget
// 0x0008 (0x0008 - 0x0000)
struct CommonWidgetGroupBase_RemoveWidget final
{
public:
	class UWidget*                                InWidget;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonWidgetGroupBase_RemoveWidget) == 0x000008, "Wrong alignment on CommonWidgetGroupBase_RemoveWidget");
static_assert(sizeof(CommonWidgetGroupBase_RemoveWidget) == 0x000008, "Wrong size on CommonWidgetGroupBase_RemoveWidget");
static_assert(offsetof(CommonWidgetGroupBase_RemoveWidget, InWidget) == 0x000000, "Member 'CommonWidgetGroupBase_RemoveWidget::InWidget' has a wrong offset!");

// Function CommonUI.CommonButtonGroup.OnButtonHovered
// 0x0008 (0x0008 - 0x0000)
struct CommonButtonGroup_OnButtonHovered final
{
public:
	class UCommonButton*                          BaseButton;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonGroup_OnButtonHovered) == 0x000008, "Wrong alignment on CommonButtonGroup_OnButtonHovered");
static_assert(sizeof(CommonButtonGroup_OnButtonHovered) == 0x000008, "Wrong size on CommonButtonGroup_OnButtonHovered");
static_assert(offsetof(CommonButtonGroup_OnButtonHovered, BaseButton) == 0x000000, "Member 'CommonButtonGroup_OnButtonHovered::BaseButton' has a wrong offset!");

// Function CommonUI.CommonButtonGroup.OnButtonUnhovered
// 0x0008 (0x0008 - 0x0000)
struct CommonButtonGroup_OnButtonUnhovered final
{
public:
	class UCommonButton*                          BaseButton;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonGroup_OnButtonUnhovered) == 0x000008, "Wrong alignment on CommonButtonGroup_OnButtonUnhovered");
static_assert(sizeof(CommonButtonGroup_OnButtonUnhovered) == 0x000008, "Wrong size on CommonButtonGroup_OnButtonUnhovered");
static_assert(offsetof(CommonButtonGroup_OnButtonUnhovered, BaseButton) == 0x000000, "Member 'CommonButtonGroup_OnButtonUnhovered::BaseButton' has a wrong offset!");

// Function CommonUI.CommonButtonGroup.OnHandleButtonClicked
// 0x0008 (0x0008 - 0x0000)
struct CommonButtonGroup_OnHandleButtonClicked final
{
public:
	class UCommonButton*                          BaseButton;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonGroup_OnHandleButtonClicked) == 0x000008, "Wrong alignment on CommonButtonGroup_OnHandleButtonClicked");
static_assert(sizeof(CommonButtonGroup_OnHandleButtonClicked) == 0x000008, "Wrong size on CommonButtonGroup_OnHandleButtonClicked");
static_assert(offsetof(CommonButtonGroup_OnHandleButtonClicked, BaseButton) == 0x000000, "Member 'CommonButtonGroup_OnHandleButtonClicked::BaseButton' has a wrong offset!");

// Function CommonUI.CommonButtonGroup.OnHandleButtonDoubleClicked
// 0x0008 (0x0008 - 0x0000)
struct CommonButtonGroup_OnHandleButtonDoubleClicked final
{
public:
	class UCommonButton*                          BaseButton;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonButtonGroup_OnHandleButtonDoubleClicked) == 0x000008, "Wrong alignment on CommonButtonGroup_OnHandleButtonDoubleClicked");
static_assert(sizeof(CommonButtonGroup_OnHandleButtonDoubleClicked) == 0x000008, "Wrong size on CommonButtonGroup_OnHandleButtonDoubleClicked");
static_assert(offsetof(CommonButtonGroup_OnHandleButtonDoubleClicked, BaseButton) == 0x000000, "Member 'CommonButtonGroup_OnHandleButtonDoubleClicked::BaseButton' has a wrong offset!");

// Function CommonUI.CommonButtonGroup.OnSelectionStateChanged
// 0x0010 (0x0010 - 0x0000)
struct CommonButtonGroup_OnSelectionStateChanged final
{
public:
	class UCommonButton*                          BaseButton;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsSelected;                                       // 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(CommonButtonGroup_OnSelectionStateChanged) == 0x000008, "Wrong alignment on CommonButtonGroup_OnSelectionStateChanged");
static_assert(sizeof(CommonButtonGroup_OnSelectionStateChanged) == 0x000010, "Wrong size on CommonButtonGroup_OnSelectionStateChanged");
static_assert(offsetof(CommonButtonGroup_OnSelectionStateChanged, BaseButton) == 0x000000, "Member 'CommonButtonGroup_OnSelectionStateChanged::BaseButton' has a wrong offset!");
static_assert(offsetof(CommonButtonGroup_OnSelectionStateChanged, bIsSelected) == 0x000008, "Member 'CommonButtonGroup_OnSelectionStateChanged::bIsSelected' has a wrong offset!");

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

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

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

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

// Function CommonUI.CommonButtonGroup.FindButtonIndex
// 0x0010 (0x0010 - 0x0000)
struct CommonButtonGroup_FindButtonIndex final
{
public:
	const class UCommonButton*                    ButtonToFind;                                      // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, 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(CommonButtonGroup_FindButtonIndex) == 0x000008, "Wrong alignment on CommonButtonGroup_FindButtonIndex");
static_assert(sizeof(CommonButtonGroup_FindButtonIndex) == 0x000010, "Wrong size on CommonButtonGroup_FindButtonIndex");
static_assert(offsetof(CommonButtonGroup_FindButtonIndex, ButtonToFind) == 0x000000, "Member 'CommonButtonGroup_FindButtonIndex::ButtonToFind' has a wrong offset!");
static_assert(offsetof(CommonButtonGroup_FindButtonIndex, ReturnValue) == 0x000008, "Member 'CommonButtonGroup_FindButtonIndex::ReturnValue' has a wrong offset!");

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

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

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

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

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

// Function CommonUI.CommonTextBlock.SetStyle
// 0x0008 (0x0008 - 0x0000)
struct CommonTextBlock_SetStyle final
{
public:
	TSubclassOf<class UCommonTextStyle>           InStyle;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTextBlock_SetStyle) == 0x000008, "Wrong alignment on CommonTextBlock_SetStyle");
static_assert(sizeof(CommonTextBlock_SetStyle) == 0x000008, "Wrong size on CommonTextBlock_SetStyle");
static_assert(offsetof(CommonTextBlock_SetStyle, InStyle) == 0x000000, "Member 'CommonTextBlock_SetStyle::InStyle' has a wrong offset!");

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

// Function CommonUI.CommonDateTimeTextBlock.SetCountDownCompletionText
// 0x0018 (0x0018 - 0x0000)
struct CommonDateTimeTextBlock_SetCountDownCompletionText final
{
public:
	class FText                                   InCompletionText;                                  // 0x0000(0x0018)(ConstParm, Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonDateTimeTextBlock_SetCountDownCompletionText) == 0x000008, "Wrong alignment on CommonDateTimeTextBlock_SetCountDownCompletionText");
static_assert(sizeof(CommonDateTimeTextBlock_SetCountDownCompletionText) == 0x000018, "Wrong size on CommonDateTimeTextBlock_SetCountDownCompletionText");
static_assert(offsetof(CommonDateTimeTextBlock_SetCountDownCompletionText, InCompletionText) == 0x000000, "Member 'CommonDateTimeTextBlock_SetCountDownCompletionText::InCompletionText' has a wrong offset!");

// Function CommonUI.CommonDateTimeTextBlock.SetDateTimeValue
// 0x0010 (0x0010 - 0x0000)
struct CommonDateTimeTextBlock_SetDateTimeValue final
{
public:
	struct FDateTime                              InDateTime;                                        // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowAsCountdown;                                  // 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(CommonDateTimeTextBlock_SetDateTimeValue) == 0x000008, "Wrong alignment on CommonDateTimeTextBlock_SetDateTimeValue");
static_assert(sizeof(CommonDateTimeTextBlock_SetDateTimeValue) == 0x000010, "Wrong size on CommonDateTimeTextBlock_SetDateTimeValue");
static_assert(offsetof(CommonDateTimeTextBlock_SetDateTimeValue, InDateTime) == 0x000000, "Member 'CommonDateTimeTextBlock_SetDateTimeValue::InDateTime' has a wrong offset!");
static_assert(offsetof(CommonDateTimeTextBlock_SetDateTimeValue, bShowAsCountdown) == 0x000008, "Member 'CommonDateTimeTextBlock_SetDateTimeValue::bShowAsCountdown' has a wrong offset!");

// Function CommonUI.CommonDateTimeTextBlock.SetTimespanValue
// 0x0008 (0x0008 - 0x0000)
struct CommonDateTimeTextBlock_SetTimespanValue final
{
public:
	struct FTimespan                              InTimespan;                                        // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonDateTimeTextBlock_SetTimespanValue) == 0x000008, "Wrong alignment on CommonDateTimeTextBlock_SetTimespanValue");
static_assert(sizeof(CommonDateTimeTextBlock_SetTimespanValue) == 0x000008, "Wrong size on CommonDateTimeTextBlock_SetTimespanValue");
static_assert(offsetof(CommonDateTimeTextBlock_SetTimespanValue, InTimespan) == 0x000000, "Member 'CommonDateTimeTextBlock_SetTimespanValue::InTimespan' has a wrong offset!");

// Function CommonUI.CommonDateTimeTextBlock.GetDateTime
// 0x0008 (0x0008 - 0x0000)
struct CommonDateTimeTextBlock_GetDateTime final
{
public:
	struct FDateTime                              ReturnValue;                                       // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonDateTimeTextBlock_GetDateTime) == 0x000008, "Wrong alignment on CommonDateTimeTextBlock_GetDateTime");
static_assert(sizeof(CommonDateTimeTextBlock_GetDateTime) == 0x000008, "Wrong size on CommonDateTimeTextBlock_GetDateTime");
static_assert(offsetof(CommonDateTimeTextBlock_GetDateTime, ReturnValue) == 0x000000, "Member 'CommonDateTimeTextBlock_GetDateTime::ReturnValue' has a wrong offset!");

// Function CommonUI.CommonInputManager.GetAvailableInputActions
// 0x0018 (0x0018 - 0x0000)
struct CommonInputManager_GetAvailableInputActions final
{
public:
	TArray<struct FCommonInputActionHandlerData>  AvailableInputActions;                             // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, 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(CommonInputManager_GetAvailableInputActions) == 0x000008, "Wrong alignment on CommonInputManager_GetAvailableInputActions");
static_assert(sizeof(CommonInputManager_GetAvailableInputActions) == 0x000018, "Wrong size on CommonInputManager_GetAvailableInputActions");
static_assert(offsetof(CommonInputManager_GetAvailableInputActions, AvailableInputActions) == 0x000000, "Member 'CommonInputManager_GetAvailableInputActions::AvailableInputActions' has a wrong offset!");
static_assert(offsetof(CommonInputManager_GetAvailableInputActions, ReturnValue) == 0x000010, "Member 'CommonInputManager_GetAvailableInputActions::ReturnValue' has a wrong offset!");

// Function CommonUI.CommonInputManager.PopActivatablePanel
// 0x0008 (0x0008 - 0x0000)
struct CommonInputManager_PopActivatablePanel final
{
public:
	class UCommonActivatablePanel*                ActivatablePanel;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonInputManager_PopActivatablePanel) == 0x000008, "Wrong alignment on CommonInputManager_PopActivatablePanel");
static_assert(sizeof(CommonInputManager_PopActivatablePanel) == 0x000008, "Wrong size on CommonInputManager_PopActivatablePanel");
static_assert(offsetof(CommonInputManager_PopActivatablePanel, ActivatablePanel) == 0x000000, "Member 'CommonInputManager_PopActivatablePanel::ActivatablePanel' has a wrong offset!");

// Function CommonUI.CommonInputManager.PushActivatablePanel
// 0x0010 (0x0010 - 0x0000)
struct CommonInputManager_PushActivatablePanel final
{
public:
	class UCommonActivatablePanel*                ActivatablePanel;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIntroPanel;                                       // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bOutroPanelBelow;                                  // 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(CommonInputManager_PushActivatablePanel) == 0x000008, "Wrong alignment on CommonInputManager_PushActivatablePanel");
static_assert(sizeof(CommonInputManager_PushActivatablePanel) == 0x000010, "Wrong size on CommonInputManager_PushActivatablePanel");
static_assert(offsetof(CommonInputManager_PushActivatablePanel, ActivatablePanel) == 0x000000, "Member 'CommonInputManager_PushActivatablePanel::ActivatablePanel' has a wrong offset!");
static_assert(offsetof(CommonInputManager_PushActivatablePanel, bIntroPanel) == 0x000008, "Member 'CommonInputManager_PushActivatablePanel::bIntroPanel' has a wrong offset!");
static_assert(offsetof(CommonInputManager_PushActivatablePanel, bOutroPanelBelow) == 0x000009, "Member 'CommonInputManager_PushActivatablePanel::bOutroPanelBelow' has a wrong offset!");

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

// Function CommonUI.CommonInputManager.StartListeningForExistingHeldAction
// 0x0038 (0x0038 - 0x0000)
struct CommonInputManager_StartListeningForExistingHeldAction final
{
public:
	struct FDataTableRowHandle                    InputActionDataRow;                                // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void()>                             CompleteEvent;                                     // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(float HeldPercent)>            ProgressEvent;                                     // 0x0020(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, 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(CommonInputManager_StartListeningForExistingHeldAction) == 0x000008, "Wrong alignment on CommonInputManager_StartListeningForExistingHeldAction");
static_assert(sizeof(CommonInputManager_StartListeningForExistingHeldAction) == 0x000038, "Wrong size on CommonInputManager_StartListeningForExistingHeldAction");
static_assert(offsetof(CommonInputManager_StartListeningForExistingHeldAction, InputActionDataRow) == 0x000000, "Member 'CommonInputManager_StartListeningForExistingHeldAction::InputActionDataRow' has a wrong offset!");
static_assert(offsetof(CommonInputManager_StartListeningForExistingHeldAction, CompleteEvent) == 0x000010, "Member 'CommonInputManager_StartListeningForExistingHeldAction::CompleteEvent' has a wrong offset!");
static_assert(offsetof(CommonInputManager_StartListeningForExistingHeldAction, ProgressEvent) == 0x000020, "Member 'CommonInputManager_StartListeningForExistingHeldAction::ProgressEvent' has a wrong offset!");
static_assert(offsetof(CommonInputManager_StartListeningForExistingHeldAction, ReturnValue) == 0x000030, "Member 'CommonInputManager_StartListeningForExistingHeldAction::ReturnValue' has a wrong offset!");

// Function CommonUI.CommonInputManager.StopListeningForExistingHeldAction
// 0x0038 (0x0038 - 0x0000)
struct CommonInputManager_StopListeningForExistingHeldAction final
{
public:
	struct FDataTableRowHandle                    InputActionDataRow;                                // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void()>                             CompleteEvent;                                     // 0x0010(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(float HeldPercent)>            ProgressEvent;                                     // 0x0020(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, 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(CommonInputManager_StopListeningForExistingHeldAction) == 0x000008, "Wrong alignment on CommonInputManager_StopListeningForExistingHeldAction");
static_assert(sizeof(CommonInputManager_StopListeningForExistingHeldAction) == 0x000038, "Wrong size on CommonInputManager_StopListeningForExistingHeldAction");
static_assert(offsetof(CommonInputManager_StopListeningForExistingHeldAction, InputActionDataRow) == 0x000000, "Member 'CommonInputManager_StopListeningForExistingHeldAction::InputActionDataRow' has a wrong offset!");
static_assert(offsetof(CommonInputManager_StopListeningForExistingHeldAction, CompleteEvent) == 0x000010, "Member 'CommonInputManager_StopListeningForExistingHeldAction::CompleteEvent' has a wrong offset!");
static_assert(offsetof(CommonInputManager_StopListeningForExistingHeldAction, ProgressEvent) == 0x000020, "Member 'CommonInputManager_StopListeningForExistingHeldAction::ProgressEvent' has a wrong offset!");
static_assert(offsetof(CommonInputManager_StopListeningForExistingHeldAction, ReturnValue) == 0x000030, "Member 'CommonInputManager_StopListeningForExistingHeldAction::ReturnValue' has a wrong offset!");

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

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

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

// Function CommonUI.CommonInputManager.IsPanelOnStack
// 0x0010 (0x0010 - 0x0000)
struct CommonInputManager_IsPanelOnStack final
{
public:
	const class UCommonActivatablePanel*          InPanel;                                           // 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(CommonInputManager_IsPanelOnStack) == 0x000008, "Wrong alignment on CommonInputManager_IsPanelOnStack");
static_assert(sizeof(CommonInputManager_IsPanelOnStack) == 0x000010, "Wrong size on CommonInputManager_IsPanelOnStack");
static_assert(offsetof(CommonInputManager_IsPanelOnStack, InPanel) == 0x000000, "Member 'CommonInputManager_IsPanelOnStack::InPanel' has a wrong offset!");
static_assert(offsetof(CommonInputManager_IsPanelOnStack, ReturnValue) == 0x000008, "Member 'CommonInputManager_IsPanelOnStack::ReturnValue' has a wrong offset!");

// Function CommonUI.CommonInputReflector.OnButtonAdded
// 0x0028 (0x0028 - 0x0000)
struct CommonInputReflector_OnButtonAdded final
{
public:
	class UCommonButton*                          AddedButton;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCommonInputActionHandlerData          Data;                                              // 0x0008(0x0020)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonInputReflector_OnButtonAdded) == 0x000008, "Wrong alignment on CommonInputReflector_OnButtonAdded");
static_assert(sizeof(CommonInputReflector_OnButtonAdded) == 0x000028, "Wrong size on CommonInputReflector_OnButtonAdded");
static_assert(offsetof(CommonInputReflector_OnButtonAdded, AddedButton) == 0x000000, "Member 'CommonInputReflector_OnButtonAdded::AddedButton' has a wrong offset!");
static_assert(offsetof(CommonInputReflector_OnButtonAdded, Data) == 0x000008, "Member 'CommonInputReflector_OnButtonAdded::Data' has a wrong offset!");

// Function CommonUI.CommonLazyImage.SetBrushFromLazyDisplayAsset
// 0x0030 (0x0030 - 0x0000)
struct CommonLazyImage_SetBrushFromLazyDisplayAsset final
{
public:
	TSoftObjectPtr<class UObject>                 LazyObject;                                        // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMatchTextureSize;                                 // 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(CommonLazyImage_SetBrushFromLazyDisplayAsset) == 0x000008, "Wrong alignment on CommonLazyImage_SetBrushFromLazyDisplayAsset");
static_assert(sizeof(CommonLazyImage_SetBrushFromLazyDisplayAsset) == 0x000030, "Wrong size on CommonLazyImage_SetBrushFromLazyDisplayAsset");
static_assert(offsetof(CommonLazyImage_SetBrushFromLazyDisplayAsset, LazyObject) == 0x000000, "Member 'CommonLazyImage_SetBrushFromLazyDisplayAsset::LazyObject' has a wrong offset!");
static_assert(offsetof(CommonLazyImage_SetBrushFromLazyDisplayAsset, bMatchTextureSize) == 0x000028, "Member 'CommonLazyImage_SetBrushFromLazyDisplayAsset::bMatchTextureSize' has a wrong offset!");

// Function CommonUI.CommonLazyImage.SetBrushFromLazyMaterial
// 0x0028 (0x0028 - 0x0000)
struct CommonLazyImage_SetBrushFromLazyMaterial final
{
public:
	TSoftObjectPtr<class UMaterialInterface>      LazyMaterial;                                      // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonLazyImage_SetBrushFromLazyMaterial) == 0x000008, "Wrong alignment on CommonLazyImage_SetBrushFromLazyMaterial");
static_assert(sizeof(CommonLazyImage_SetBrushFromLazyMaterial) == 0x000028, "Wrong size on CommonLazyImage_SetBrushFromLazyMaterial");
static_assert(offsetof(CommonLazyImage_SetBrushFromLazyMaterial, LazyMaterial) == 0x000000, "Member 'CommonLazyImage_SetBrushFromLazyMaterial::LazyMaterial' has a wrong offset!");

// Function CommonUI.CommonLazyImage.SetBrushFromLazyTexture
// 0x0030 (0x0030 - 0x0000)
struct CommonLazyImage_SetBrushFromLazyTexture final
{
public:
	TSoftObjectPtr<class UTexture2D>              LazyTexture;                                       // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMatchSize;                                        // 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(CommonLazyImage_SetBrushFromLazyTexture) == 0x000008, "Wrong alignment on CommonLazyImage_SetBrushFromLazyTexture");
static_assert(sizeof(CommonLazyImage_SetBrushFromLazyTexture) == 0x000030, "Wrong size on CommonLazyImage_SetBrushFromLazyTexture");
static_assert(offsetof(CommonLazyImage_SetBrushFromLazyTexture, LazyTexture) == 0x000000, "Member 'CommonLazyImage_SetBrushFromLazyTexture::LazyTexture' has a wrong offset!");
static_assert(offsetof(CommonLazyImage_SetBrushFromLazyTexture, bMatchSize) == 0x000028, "Member 'CommonLazyImage_SetBrushFromLazyTexture::bMatchSize' has a wrong offset!");

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

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

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

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

// Function CommonUI.LoadGuardSlot.SetHorizontalAlignment
// 0x0001 (0x0001 - 0x0000)
struct LoadGuardSlot_SetHorizontalAlignment final
{
public:
	EHorizontalAlignment                          InHorizontalAlignment;                             // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(LoadGuardSlot_SetHorizontalAlignment) == 0x000001, "Wrong alignment on LoadGuardSlot_SetHorizontalAlignment");
static_assert(sizeof(LoadGuardSlot_SetHorizontalAlignment) == 0x000001, "Wrong size on LoadGuardSlot_SetHorizontalAlignment");
static_assert(offsetof(LoadGuardSlot_SetHorizontalAlignment, InHorizontalAlignment) == 0x000000, "Member 'LoadGuardSlot_SetHorizontalAlignment::InHorizontalAlignment' has a wrong offset!");

// Function CommonUI.LoadGuardSlot.SetPadding
// 0x0010 (0x0010 - 0x0000)
struct LoadGuardSlot_SetPadding final
{
public:
	struct FMargin                                InPadding;                                         // 0x0000(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(LoadGuardSlot_SetPadding) == 0x000004, "Wrong alignment on LoadGuardSlot_SetPadding");
static_assert(sizeof(LoadGuardSlot_SetPadding) == 0x000010, "Wrong size on LoadGuardSlot_SetPadding");
static_assert(offsetof(LoadGuardSlot_SetPadding, InPadding) == 0x000000, "Member 'LoadGuardSlot_SetPadding::InPadding' has a wrong offset!");

// Function CommonUI.LoadGuardSlot.SetVerticalAlignment
// 0x0001 (0x0001 - 0x0000)
struct LoadGuardSlot_SetVerticalAlignment final
{
public:
	EVerticalAlignment                            InVerticalAlignment;                               // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(LoadGuardSlot_SetVerticalAlignment) == 0x000001, "Wrong alignment on LoadGuardSlot_SetVerticalAlignment");
static_assert(sizeof(LoadGuardSlot_SetVerticalAlignment) == 0x000001, "Wrong size on LoadGuardSlot_SetVerticalAlignment");
static_assert(offsetof(LoadGuardSlot_SetVerticalAlignment, InVerticalAlignment) == 0x000000, "Member 'LoadGuardSlot_SetVerticalAlignment::InVerticalAlignment' has a wrong offset!");

// Function CommonUI.CommonLoadGuard.BP_GuardAndLoadAsset
// 0x0038 (0x0038 - 0x0000)
struct CommonLoadGuard_BP_GuardAndLoadAsset final
{
public:
	TSoftObjectPtr<class UObject>                 InLazyAsset;                                       // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void(class UObject* Object)>        OnAssetLoaded;                                     // 0x0028(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonLoadGuard_BP_GuardAndLoadAsset) == 0x000008, "Wrong alignment on CommonLoadGuard_BP_GuardAndLoadAsset");
static_assert(sizeof(CommonLoadGuard_BP_GuardAndLoadAsset) == 0x000038, "Wrong size on CommonLoadGuard_BP_GuardAndLoadAsset");
static_assert(offsetof(CommonLoadGuard_BP_GuardAndLoadAsset, InLazyAsset) == 0x000000, "Member 'CommonLoadGuard_BP_GuardAndLoadAsset::InLazyAsset' has a wrong offset!");
static_assert(offsetof(CommonLoadGuard_BP_GuardAndLoadAsset, OnAssetLoaded) == 0x000028, "Member 'CommonLoadGuard_BP_GuardAndLoadAsset::OnAssetLoaded' has a wrong offset!");

// DelegateFunction CommonUI.CommonLoadGuard.OnAssetLoaded__DelegateSignature
// 0x0008 (0x0008 - 0x0000)
struct CommonLoadGuard_OnAssetLoaded__DelegateSignature final
{
public:
	class UObject*                                Object;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonLoadGuard_OnAssetLoaded__DelegateSignature) == 0x000008, "Wrong alignment on CommonLoadGuard_OnAssetLoaded__DelegateSignature");
static_assert(sizeof(CommonLoadGuard_OnAssetLoaded__DelegateSignature) == 0x000008, "Wrong size on CommonLoadGuard_OnAssetLoaded__DelegateSignature");
static_assert(offsetof(CommonLoadGuard_OnAssetLoaded__DelegateSignature, Object) == 0x000000, "Member 'CommonLoadGuard_OnAssetLoaded__DelegateSignature::Object' has a wrong offset!");

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

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

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

// Function CommonUI.CommonNumericTextBlock.InterpolateToValue
// 0x0010 (0x0010 - 0x0000)
struct CommonNumericTextBlock_InterpolateToValue final
{
public:
	float                                         TargetValue;                                       // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaximumInterpolationDuration;                      // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinimumChangeRate;                                 // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OutroOffset;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonNumericTextBlock_InterpolateToValue) == 0x000004, "Wrong alignment on CommonNumericTextBlock_InterpolateToValue");
static_assert(sizeof(CommonNumericTextBlock_InterpolateToValue) == 0x000010, "Wrong size on CommonNumericTextBlock_InterpolateToValue");
static_assert(offsetof(CommonNumericTextBlock_InterpolateToValue, TargetValue) == 0x000000, "Member 'CommonNumericTextBlock_InterpolateToValue::TargetValue' has a wrong offset!");
static_assert(offsetof(CommonNumericTextBlock_InterpolateToValue, MaximumInterpolationDuration) == 0x000004, "Member 'CommonNumericTextBlock_InterpolateToValue::MaximumInterpolationDuration' has a wrong offset!");
static_assert(offsetof(CommonNumericTextBlock_InterpolateToValue, MinimumChangeRate) == 0x000008, "Member 'CommonNumericTextBlock_InterpolateToValue::MinimumChangeRate' has a wrong offset!");
static_assert(offsetof(CommonNumericTextBlock_InterpolateToValue, OutroOffset) == 0x00000C, "Member 'CommonNumericTextBlock_InterpolateToValue::OutroOffset' has a wrong offset!");

// DelegateFunction CommonUI.CommonNumericTextBlock.OnInterpolationEnded__DelegateSignature
// 0x0010 (0x0010 - 0x0000)
struct CommonNumericTextBlock_OnInterpolationEnded__DelegateSignature final
{
public:
	class UCommonNumericTextBlock*                NumericTextBlock;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          HadCompleted;                                      // 0x0008(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(CommonNumericTextBlock_OnInterpolationEnded__DelegateSignature) == 0x000008, "Wrong alignment on CommonNumericTextBlock_OnInterpolationEnded__DelegateSignature");
static_assert(sizeof(CommonNumericTextBlock_OnInterpolationEnded__DelegateSignature) == 0x000010, "Wrong size on CommonNumericTextBlock_OnInterpolationEnded__DelegateSignature");
static_assert(offsetof(CommonNumericTextBlock_OnInterpolationEnded__DelegateSignature, NumericTextBlock) == 0x000000, "Member 'CommonNumericTextBlock_OnInterpolationEnded__DelegateSignature::NumericTextBlock' has a wrong offset!");
static_assert(offsetof(CommonNumericTextBlock_OnInterpolationEnded__DelegateSignature, HadCompleted) == 0x000008, "Member 'CommonNumericTextBlock_OnInterpolationEnded__DelegateSignature::HadCompleted' has a wrong offset!");

// DelegateFunction CommonUI.CommonNumericTextBlock.OnOutro__DelegateSignature
// 0x0008 (0x0008 - 0x0000)
struct CommonNumericTextBlock_OnOutro__DelegateSignature final
{
public:
	class UCommonNumericTextBlock*                NumericTextBlock;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonNumericTextBlock_OnOutro__DelegateSignature) == 0x000008, "Wrong alignment on CommonNumericTextBlock_OnOutro__DelegateSignature");
static_assert(sizeof(CommonNumericTextBlock_OnOutro__DelegateSignature) == 0x000008, "Wrong size on CommonNumericTextBlock_OnOutro__DelegateSignature");
static_assert(offsetof(CommonNumericTextBlock_OnOutro__DelegateSignature, NumericTextBlock) == 0x000000, "Member 'CommonNumericTextBlock_OnOutro__DelegateSignature::NumericTextBlock' has a wrong offset!");

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

// Function CommonUI.CommonNumericTextBlock.SetNumericType
// 0x0001 (0x0001 - 0x0000)
struct CommonNumericTextBlock_SetNumericType final
{
public:
	ECommonNumericType                            InNumericType;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonNumericTextBlock_SetNumericType) == 0x000001, "Wrong alignment on CommonNumericTextBlock_SetNumericType");
static_assert(sizeof(CommonNumericTextBlock_SetNumericType) == 0x000001, "Wrong size on CommonNumericTextBlock_SetNumericType");
static_assert(offsetof(CommonNumericTextBlock_SetNumericType, InNumericType) == 0x000000, "Member 'CommonNumericTextBlock_SetNumericType::InNumericType' has a wrong offset!");

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

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

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

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

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

// Function CommonUI.CommonPopupMenu.SetOwningMenuAnchor
// 0x0008 (0x0008 - 0x0000)
struct CommonPopupMenu_SetOwningMenuAnchor final
{
public:
	const class UMenuAnchor*                      MenuAnchor;                                        // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonPopupMenu_SetOwningMenuAnchor) == 0x000008, "Wrong alignment on CommonPopupMenu_SetOwningMenuAnchor");
static_assert(sizeof(CommonPopupMenu_SetOwningMenuAnchor) == 0x000008, "Wrong size on CommonPopupMenu_SetOwningMenuAnchor");
static_assert(offsetof(CommonPopupMenu_SetOwningMenuAnchor, MenuAnchor) == 0x000000, "Member 'CommonPopupMenu_SetOwningMenuAnchor::MenuAnchor' has a wrong offset!");

// Function CommonUI.CommonRotator.PopulateTextLabels
// 0x0010 (0x0010 - 0x0000)
struct CommonRotator_PopulateTextLabels final
{
public:
	TArray<class FText>                           Labels;                                            // 0x0000(0x0010)(Parm, ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonRotator_PopulateTextLabels) == 0x000008, "Wrong alignment on CommonRotator_PopulateTextLabels");
static_assert(sizeof(CommonRotator_PopulateTextLabels) == 0x000010, "Wrong size on CommonRotator_PopulateTextLabels");
static_assert(offsetof(CommonRotator_PopulateTextLabels, Labels) == 0x000000, "Member 'CommonRotator_PopulateTextLabels::Labels' has a wrong offset!");

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

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

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

// Function CommonUI.CommonTabListWidget.DisableTabWithReason
// 0x0020 (0x0020 - 0x0000)
struct CommonTabListWidget_DisableTabWithReason final
{
public:
	class FName                                   TabNameID;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FText                                   Reason;                                            // 0x0008(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTabListWidget_DisableTabWithReason) == 0x000008, "Wrong alignment on CommonTabListWidget_DisableTabWithReason");
static_assert(sizeof(CommonTabListWidget_DisableTabWithReason) == 0x000020, "Wrong size on CommonTabListWidget_DisableTabWithReason");
static_assert(offsetof(CommonTabListWidget_DisableTabWithReason, TabNameID) == 0x000000, "Member 'CommonTabListWidget_DisableTabWithReason::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_DisableTabWithReason, Reason) == 0x000008, "Member 'CommonTabListWidget_DisableTabWithReason::Reason' has a wrong offset!");

// Function CommonUI.CommonTabListWidget.GetTabButtonByID
// 0x0010 (0x0010 - 0x0000)
struct CommonTabListWidget_GetTabButtonByID final
{
public:
	class FName                                   TabNameID;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UCommonButton*                          ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTabListWidget_GetTabButtonByID) == 0x000008, "Wrong alignment on CommonTabListWidget_GetTabButtonByID");
static_assert(sizeof(CommonTabListWidget_GetTabButtonByID) == 0x000010, "Wrong size on CommonTabListWidget_GetTabButtonByID");
static_assert(offsetof(CommonTabListWidget_GetTabButtonByID, TabNameID) == 0x000000, "Member 'CommonTabListWidget_GetTabButtonByID::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_GetTabButtonByID, ReturnValue) == 0x000008, "Member 'CommonTabListWidget_GetTabButtonByID::ReturnValue' has a wrong offset!");

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

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

// Function CommonUI.CommonTabListWidget.HandleTabButtonSelected
// 0x0010 (0x0010 - 0x0000)
struct CommonTabListWidget_HandleTabButtonSelected final
{
public:
	class UCommonButton*                          SelectedTabButton;                                 // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ButtonIndex;                                       // 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(CommonTabListWidget_HandleTabButtonSelected) == 0x000008, "Wrong alignment on CommonTabListWidget_HandleTabButtonSelected");
static_assert(sizeof(CommonTabListWidget_HandleTabButtonSelected) == 0x000010, "Wrong size on CommonTabListWidget_HandleTabButtonSelected");
static_assert(offsetof(CommonTabListWidget_HandleTabButtonSelected, SelectedTabButton) == 0x000000, "Member 'CommonTabListWidget_HandleTabButtonSelected::SelectedTabButton' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_HandleTabButtonSelected, ButtonIndex) == 0x000008, "Member 'CommonTabListWidget_HandleTabButtonSelected::ButtonIndex' has a wrong offset!");

// Function CommonUI.CommonTabListWidget.HandleTabCreated
// 0x0010 (0x0010 - 0x0000)
struct CommonTabListWidget_HandleTabCreated final
{
public:
	class FName                                   TabNameID;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UCommonButton*                          TabButton;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTabListWidget_HandleTabCreated) == 0x000008, "Wrong alignment on CommonTabListWidget_HandleTabCreated");
static_assert(sizeof(CommonTabListWidget_HandleTabCreated) == 0x000010, "Wrong size on CommonTabListWidget_HandleTabCreated");
static_assert(offsetof(CommonTabListWidget_HandleTabCreated, TabNameID) == 0x000000, "Member 'CommonTabListWidget_HandleTabCreated::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_HandleTabCreated, TabButton) == 0x000008, "Member 'CommonTabListWidget_HandleTabCreated::TabButton' has a wrong offset!");

// Function CommonUI.CommonTabListWidget.HandleTabRemoved
// 0x0010 (0x0010 - 0x0000)
struct CommonTabListWidget_HandleTabRemoved final
{
public:
	class FName                                   TabNameID;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UCommonButton*                          TabButton;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTabListWidget_HandleTabRemoved) == 0x000008, "Wrong alignment on CommonTabListWidget_HandleTabRemoved");
static_assert(sizeof(CommonTabListWidget_HandleTabRemoved) == 0x000010, "Wrong size on CommonTabListWidget_HandleTabRemoved");
static_assert(offsetof(CommonTabListWidget_HandleTabRemoved, TabNameID) == 0x000000, "Member 'CommonTabListWidget_HandleTabRemoved::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_HandleTabRemoved, TabButton) == 0x000008, "Member 'CommonTabListWidget_HandleTabRemoved::TabButton' has a wrong offset!");

// DelegateFunction CommonUI.CommonTabListWidget.OnTabButtonCreated__DelegateSignature
// 0x0010 (0x0010 - 0x0000)
struct CommonTabListWidget_OnTabButtonCreated__DelegateSignature final
{
public:
	class FName                                   TabId;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UCommonButton*                          TabButton;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTabListWidget_OnTabButtonCreated__DelegateSignature) == 0x000008, "Wrong alignment on CommonTabListWidget_OnTabButtonCreated__DelegateSignature");
static_assert(sizeof(CommonTabListWidget_OnTabButtonCreated__DelegateSignature) == 0x000010, "Wrong size on CommonTabListWidget_OnTabButtonCreated__DelegateSignature");
static_assert(offsetof(CommonTabListWidget_OnTabButtonCreated__DelegateSignature, TabId) == 0x000000, "Member 'CommonTabListWidget_OnTabButtonCreated__DelegateSignature::TabId' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_OnTabButtonCreated__DelegateSignature, TabButton) == 0x000008, "Member 'CommonTabListWidget_OnTabButtonCreated__DelegateSignature::TabButton' has a wrong offset!");

// DelegateFunction CommonUI.CommonTabListWidget.OnTabButtonRemoved__DelegateSignature
// 0x0010 (0x0010 - 0x0000)
struct CommonTabListWidget_OnTabButtonRemoved__DelegateSignature final
{
public:
	class FName                                   TabId;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UCommonButton*                          TabButton;                                         // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTabListWidget_OnTabButtonRemoved__DelegateSignature) == 0x000008, "Wrong alignment on CommonTabListWidget_OnTabButtonRemoved__DelegateSignature");
static_assert(sizeof(CommonTabListWidget_OnTabButtonRemoved__DelegateSignature) == 0x000010, "Wrong size on CommonTabListWidget_OnTabButtonRemoved__DelegateSignature");
static_assert(offsetof(CommonTabListWidget_OnTabButtonRemoved__DelegateSignature, TabId) == 0x000000, "Member 'CommonTabListWidget_OnTabButtonRemoved__DelegateSignature::TabId' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_OnTabButtonRemoved__DelegateSignature, TabButton) == 0x000008, "Member 'CommonTabListWidget_OnTabButtonRemoved__DelegateSignature::TabButton' has a wrong offset!");

// DelegateFunction CommonUI.CommonTabListWidget.OnTabSelected__DelegateSignature
// 0x0008 (0x0008 - 0x0000)
struct CommonTabListWidget_OnTabSelected__DelegateSignature final
{
public:
	class FName                                   TabId;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTabListWidget_OnTabSelected__DelegateSignature) == 0x000004, "Wrong alignment on CommonTabListWidget_OnTabSelected__DelegateSignature");
static_assert(sizeof(CommonTabListWidget_OnTabSelected__DelegateSignature) == 0x000008, "Wrong size on CommonTabListWidget_OnTabSelected__DelegateSignature");
static_assert(offsetof(CommonTabListWidget_OnTabSelected__DelegateSignature, TabId) == 0x000000, "Member 'CommonTabListWidget_OnTabSelected__DelegateSignature::TabId' has a wrong offset!");

// Function CommonUI.CommonTabListWidget.RegisterTab
// 0x0020 (0x0020 - 0x0000)
struct CommonTabListWidget_RegisterTab final
{
public:
	class FName                                   TabNameID;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UCommonButton>              ButtonWidgetType;                                  // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidget*                                ContentWidget;                                     // 0x0010(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, 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(CommonTabListWidget_RegisterTab) == 0x000008, "Wrong alignment on CommonTabListWidget_RegisterTab");
static_assert(sizeof(CommonTabListWidget_RegisterTab) == 0x000020, "Wrong size on CommonTabListWidget_RegisterTab");
static_assert(offsetof(CommonTabListWidget_RegisterTab, TabNameID) == 0x000000, "Member 'CommonTabListWidget_RegisterTab::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_RegisterTab, ButtonWidgetType) == 0x000008, "Member 'CommonTabListWidget_RegisterTab::ButtonWidgetType' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_RegisterTab, ContentWidget) == 0x000010, "Member 'CommonTabListWidget_RegisterTab::ContentWidget' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_RegisterTab, ReturnValue) == 0x000018, "Member 'CommonTabListWidget_RegisterTab::ReturnValue' has a wrong offset!");

// Function CommonUI.CommonTabListWidget.RemoveTab
// 0x000C (0x000C - 0x0000)
struct CommonTabListWidget_RemoveTab final
{
public:
	class FName                                   TabNameID;                                         // 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(CommonTabListWidget_RemoveTab) == 0x000004, "Wrong alignment on CommonTabListWidget_RemoveTab");
static_assert(sizeof(CommonTabListWidget_RemoveTab) == 0x00000C, "Wrong size on CommonTabListWidget_RemoveTab");
static_assert(offsetof(CommonTabListWidget_RemoveTab, TabNameID) == 0x000000, "Member 'CommonTabListWidget_RemoveTab::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_RemoveTab, ReturnValue) == 0x000008, "Member 'CommonTabListWidget_RemoveTab::ReturnValue' has a wrong offset!");

// Function CommonUI.CommonTabListWidget.SelectTabByID
// 0x000C (0x000C - 0x0000)
struct CommonTabListWidget_SelectTabByID final
{
public:
	class FName                                   TabNameID;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSuppressClickFeedback;                            // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0009(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x2];                                        // 0x000A(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(CommonTabListWidget_SelectTabByID) == 0x000004, "Wrong alignment on CommonTabListWidget_SelectTabByID");
static_assert(sizeof(CommonTabListWidget_SelectTabByID) == 0x00000C, "Wrong size on CommonTabListWidget_SelectTabByID");
static_assert(offsetof(CommonTabListWidget_SelectTabByID, TabNameID) == 0x000000, "Member 'CommonTabListWidget_SelectTabByID::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_SelectTabByID, bSuppressClickFeedback) == 0x000008, "Member 'CommonTabListWidget_SelectTabByID::bSuppressClickFeedback' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_SelectTabByID, ReturnValue) == 0x000009, "Member 'CommonTabListWidget_SelectTabByID::ReturnValue' has a wrong offset!");

// Function CommonUI.CommonTabListWidget.SetLinkedSwitcher
// 0x0008 (0x0008 - 0x0000)
struct CommonTabListWidget_SetLinkedSwitcher final
{
public:
	class UCommonWidgetSwitcher*                  CommonSwitcher;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTabListWidget_SetLinkedSwitcher) == 0x000008, "Wrong alignment on CommonTabListWidget_SetLinkedSwitcher");
static_assert(sizeof(CommonTabListWidget_SetLinkedSwitcher) == 0x000008, "Wrong size on CommonTabListWidget_SetLinkedSwitcher");
static_assert(offsetof(CommonTabListWidget_SetLinkedSwitcher, CommonSwitcher) == 0x000000, "Member 'CommonTabListWidget_SetLinkedSwitcher::CommonSwitcher' has a wrong offset!");

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

// Function CommonUI.CommonTabListWidget.SetTabEnabled
// 0x000C (0x000C - 0x0000)
struct CommonTabListWidget_SetTabEnabled final
{
public:
	class FName                                   TabNameID;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnable;                                           // 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(CommonTabListWidget_SetTabEnabled) == 0x000004, "Wrong alignment on CommonTabListWidget_SetTabEnabled");
static_assert(sizeof(CommonTabListWidget_SetTabEnabled) == 0x00000C, "Wrong size on CommonTabListWidget_SetTabEnabled");
static_assert(offsetof(CommonTabListWidget_SetTabEnabled, TabNameID) == 0x000000, "Member 'CommonTabListWidget_SetTabEnabled::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_SetTabEnabled, bEnable) == 0x000008, "Member 'CommonTabListWidget_SetTabEnabled::bEnable' has a wrong offset!");

// Function CommonUI.CommonTabListWidget.SetTabInteractionEnabled
// 0x000C (0x000C - 0x0000)
struct CommonTabListWidget_SetTabInteractionEnabled final
{
public:
	class FName                                   TabNameID;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnable;                                           // 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(CommonTabListWidget_SetTabInteractionEnabled) == 0x000004, "Wrong alignment on CommonTabListWidget_SetTabInteractionEnabled");
static_assert(sizeof(CommonTabListWidget_SetTabInteractionEnabled) == 0x00000C, "Wrong size on CommonTabListWidget_SetTabInteractionEnabled");
static_assert(offsetof(CommonTabListWidget_SetTabInteractionEnabled, TabNameID) == 0x000000, "Member 'CommonTabListWidget_SetTabInteractionEnabled::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_SetTabInteractionEnabled, bEnable) == 0x000008, "Member 'CommonTabListWidget_SetTabInteractionEnabled::bEnable' has a wrong offset!");

// Function CommonUI.CommonTabListWidget.SetTabVisibility
// 0x000C (0x000C - 0x0000)
struct CommonTabListWidget_SetTabVisibility final
{
public:
	class FName                                   TabNameID;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESlateVisibility                              NewVisibility;                                     // 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(CommonTabListWidget_SetTabVisibility) == 0x000004, "Wrong alignment on CommonTabListWidget_SetTabVisibility");
static_assert(sizeof(CommonTabListWidget_SetTabVisibility) == 0x00000C, "Wrong size on CommonTabListWidget_SetTabVisibility");
static_assert(offsetof(CommonTabListWidget_SetTabVisibility, TabNameID) == 0x000000, "Member 'CommonTabListWidget_SetTabVisibility::TabNameID' has a wrong offset!");
static_assert(offsetof(CommonTabListWidget_SetTabVisibility, NewVisibility) == 0x000008, "Member 'CommonTabListWidget_SetTabVisibility::NewVisibility' has a wrong offset!");

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

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

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

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

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

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

// Function CommonUI.CommonTextStyle.GetFont
// 0x0050 (0x0050 - 0x0000)
struct CommonTextStyle_GetFont final
{
public:
	struct FSlateFontInfo                         OutFont;                                           // 0x0000(0x0050)(Parm, OutParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTextStyle_GetFont) == 0x000008, "Wrong alignment on CommonTextStyle_GetFont");
static_assert(sizeof(CommonTextStyle_GetFont) == 0x000050, "Wrong size on CommonTextStyle_GetFont");
static_assert(offsetof(CommonTextStyle_GetFont, OutFont) == 0x000000, "Member 'CommonTextStyle_GetFont::OutFont' has a wrong offset!");

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

// Function CommonUI.CommonTextStyle.GetMargin
// 0x0010 (0x0010 - 0x0000)
struct CommonTextStyle_GetMargin final
{
public:
	struct FMargin                                OutMargin;                                         // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTextStyle_GetMargin) == 0x000004, "Wrong alignment on CommonTextStyle_GetMargin");
static_assert(sizeof(CommonTextStyle_GetMargin) == 0x000010, "Wrong size on CommonTextStyle_GetMargin");
static_assert(offsetof(CommonTextStyle_GetMargin, OutMargin) == 0x000000, "Member 'CommonTextStyle_GetMargin::OutMargin' has a wrong offset!");

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

// Function CommonUI.CommonTextStyle.GetShadowOffset
// 0x0008 (0x0008 - 0x0000)
struct CommonTextStyle_GetShadowOffset final
{
public:
	struct FVector2D                              OutShadowOffset;                                   // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTextStyle_GetShadowOffset) == 0x000004, "Wrong alignment on CommonTextStyle_GetShadowOffset");
static_assert(sizeof(CommonTextStyle_GetShadowOffset) == 0x000008, "Wrong size on CommonTextStyle_GetShadowOffset");
static_assert(offsetof(CommonTextStyle_GetShadowOffset, OutShadowOffset) == 0x000000, "Member 'CommonTextStyle_GetShadowOffset::OutShadowOffset' has a wrong offset!");

// Function CommonUI.CommonTextStyle.GetStrikeBrush
// 0x0088 (0x0088 - 0x0000)
struct CommonTextStyle_GetStrikeBrush final
{
public:
	struct FSlateBrush                            OutStrikeBrush;                                    // 0x0000(0x0088)(Parm, OutParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonTextStyle_GetStrikeBrush) == 0x000008, "Wrong alignment on CommonTextStyle_GetStrikeBrush");
static_assert(sizeof(CommonTextStyle_GetStrikeBrush) == 0x000088, "Wrong size on CommonTextStyle_GetStrikeBrush");
static_assert(offsetof(CommonTextStyle_GetStrikeBrush, OutStrikeBrush) == 0x000000, "Member 'CommonTextStyle_GetStrikeBrush::OutStrikeBrush' has a wrong offset!");

// Function CommonUI.CommonUILibrary.FindParentWidgetOfType
// 0x0018 (0x0018 - 0x0000)
struct CommonUILibrary_FindParentWidgetOfType final
{
public:
	class UWidget*                                StartingWidget;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UWidget>                    Type;                                              // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidget*                                ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonUILibrary_FindParentWidgetOfType) == 0x000008, "Wrong alignment on CommonUILibrary_FindParentWidgetOfType");
static_assert(sizeof(CommonUILibrary_FindParentWidgetOfType) == 0x000018, "Wrong size on CommonUILibrary_FindParentWidgetOfType");
static_assert(offsetof(CommonUILibrary_FindParentWidgetOfType, StartingWidget) == 0x000000, "Member 'CommonUILibrary_FindParentWidgetOfType::StartingWidget' has a wrong offset!");
static_assert(offsetof(CommonUILibrary_FindParentWidgetOfType, Type) == 0x000008, "Member 'CommonUILibrary_FindParentWidgetOfType::Type' has a wrong offset!");
static_assert(offsetof(CommonUILibrary_FindParentWidgetOfType, ReturnValue) == 0x000010, "Member 'CommonUILibrary_FindParentWidgetOfType::ReturnValue' has a wrong offset!");

// DelegateFunction CommonUI.CommonUISubsystem.InputMethodChangedDelegate__DelegateSignature
// 0x0001 (0x0001 - 0x0000)
struct CommonUISubsystem_InputMethodChangedDelegate__DelegateSignature final
{
public:
	bool                                          bUsingGamepad;                                     // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonUISubsystem_InputMethodChangedDelegate__DelegateSignature) == 0x000001, "Wrong alignment on CommonUISubsystem_InputMethodChangedDelegate__DelegateSignature");
static_assert(sizeof(CommonUISubsystem_InputMethodChangedDelegate__DelegateSignature) == 0x000001, "Wrong size on CommonUISubsystem_InputMethodChangedDelegate__DelegateSignature");
static_assert(offsetof(CommonUISubsystem_InputMethodChangedDelegate__DelegateSignature, bUsingGamepad) == 0x000000, "Member 'CommonUISubsystem_InputMethodChangedDelegate__DelegateSignature::bUsingGamepad' has a wrong offset!");

// DelegateFunction CommonUI.CommonUISubsystem.InputSuspensionChanged__DelegateSignature
// 0x0001 (0x0001 - 0x0000)
struct CommonUISubsystem_InputSuspensionChanged__DelegateSignature final
{
public:
	bool                                          bInputSuspended;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonUISubsystem_InputSuspensionChanged__DelegateSignature) == 0x000001, "Wrong alignment on CommonUISubsystem_InputSuspensionChanged__DelegateSignature");
static_assert(sizeof(CommonUISubsystem_InputSuspensionChanged__DelegateSignature) == 0x000001, "Wrong size on CommonUISubsystem_InputSuspensionChanged__DelegateSignature");
static_assert(offsetof(CommonUISubsystem_InputSuspensionChanged__DelegateSignature, bInputSuspended) == 0x000000, "Member 'CommonUISubsystem_InputSuspensionChanged__DelegateSignature::bInputSuspended' has a wrong offset!");

// Function CommonUI.CommonUISubsystem.GetInputActionButtonIcon
// 0x00A0 (0x00A0 - 0x0000)
struct CommonUISubsystem_GetInputActionButtonIcon final
{
public:
	struct FDataTableRowHandle                    InputActionRowHandle;                              // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	ECommonInputType                              InputType;                                         // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECommonGamepadType                            GamepadType;                                       // 0x0011(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12[0x6];                                       // 0x0012(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateBrush                            ReturnValue;                                       // 0x0018(0x0088)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonUISubsystem_GetInputActionButtonIcon) == 0x000008, "Wrong alignment on CommonUISubsystem_GetInputActionButtonIcon");
static_assert(sizeof(CommonUISubsystem_GetInputActionButtonIcon) == 0x0000A0, "Wrong size on CommonUISubsystem_GetInputActionButtonIcon");
static_assert(offsetof(CommonUISubsystem_GetInputActionButtonIcon, InputActionRowHandle) == 0x000000, "Member 'CommonUISubsystem_GetInputActionButtonIcon::InputActionRowHandle' has a wrong offset!");
static_assert(offsetof(CommonUISubsystem_GetInputActionButtonIcon, InputType) == 0x000010, "Member 'CommonUISubsystem_GetInputActionButtonIcon::InputType' has a wrong offset!");
static_assert(offsetof(CommonUISubsystem_GetInputActionButtonIcon, GamepadType) == 0x000011, "Member 'CommonUISubsystem_GetInputActionButtonIcon::GamepadType' has a wrong offset!");
static_assert(offsetof(CommonUISubsystem_GetInputActionButtonIcon, ReturnValue) == 0x000018, "Member 'CommonUISubsystem_GetInputActionButtonIcon::ReturnValue' has a wrong offset!");

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

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

// Function CommonUI.CommonWidgetCarousel.SetActiveWidget
// 0x0008 (0x0008 - 0x0000)
struct CommonWidgetCarousel_SetActiveWidget final
{
public:
	class UWidget*                                Widget;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonWidgetCarousel_SetActiveWidget) == 0x000008, "Wrong alignment on CommonWidgetCarousel_SetActiveWidget");
static_assert(sizeof(CommonWidgetCarousel_SetActiveWidget) == 0x000008, "Wrong size on CommonWidgetCarousel_SetActiveWidget");
static_assert(offsetof(CommonWidgetCarousel_SetActiveWidget, Widget) == 0x000000, "Member 'CommonWidgetCarousel_SetActiveWidget::Widget' has a wrong offset!");

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

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

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

// Function CommonUI.CommonWidgetCarouselNavBar.HandleButtonClicked
// 0x0010 (0x0010 - 0x0000)
struct CommonWidgetCarouselNavBar_HandleButtonClicked final
{
public:
	class UCommonButton*                          AssociatedButton;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ButtonIndex;                                       // 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(CommonWidgetCarouselNavBar_HandleButtonClicked) == 0x000008, "Wrong alignment on CommonWidgetCarouselNavBar_HandleButtonClicked");
static_assert(sizeof(CommonWidgetCarouselNavBar_HandleButtonClicked) == 0x000010, "Wrong size on CommonWidgetCarouselNavBar_HandleButtonClicked");
static_assert(offsetof(CommonWidgetCarouselNavBar_HandleButtonClicked, AssociatedButton) == 0x000000, "Member 'CommonWidgetCarouselNavBar_HandleButtonClicked::AssociatedButton' has a wrong offset!");
static_assert(offsetof(CommonWidgetCarouselNavBar_HandleButtonClicked, ButtonIndex) == 0x000008, "Member 'CommonWidgetCarouselNavBar_HandleButtonClicked::ButtonIndex' has a wrong offset!");

// Function CommonUI.CommonWidgetCarouselNavBar.HandlePageChanged
// 0x0010 (0x0010 - 0x0000)
struct CommonWidgetCarouselNavBar_HandlePageChanged final
{
public:
	class UCommonWidgetCarousel*                  CommonCarousel;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PageIndex;                                         // 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(CommonWidgetCarouselNavBar_HandlePageChanged) == 0x000008, "Wrong alignment on CommonWidgetCarouselNavBar_HandlePageChanged");
static_assert(sizeof(CommonWidgetCarouselNavBar_HandlePageChanged) == 0x000010, "Wrong size on CommonWidgetCarouselNavBar_HandlePageChanged");
static_assert(offsetof(CommonWidgetCarouselNavBar_HandlePageChanged, CommonCarousel) == 0x000000, "Member 'CommonWidgetCarouselNavBar_HandlePageChanged::CommonCarousel' has a wrong offset!");
static_assert(offsetof(CommonWidgetCarouselNavBar_HandlePageChanged, PageIndex) == 0x000008, "Member 'CommonWidgetCarouselNavBar_HandlePageChanged::PageIndex' has a wrong offset!");

// Function CommonUI.CommonWidgetCarouselNavBar.SetLinkedCarousel
// 0x0008 (0x0008 - 0x0000)
struct CommonWidgetCarouselNavBar_SetLinkedCarousel final
{
public:
	class UCommonWidgetCarousel*                  CommonCarousel;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonWidgetCarouselNavBar_SetLinkedCarousel) == 0x000008, "Wrong alignment on CommonWidgetCarouselNavBar_SetLinkedCarousel");
static_assert(sizeof(CommonWidgetCarouselNavBar_SetLinkedCarousel) == 0x000008, "Wrong size on CommonWidgetCarouselNavBar_SetLinkedCarousel");
static_assert(offsetof(CommonWidgetCarouselNavBar_SetLinkedCarousel, CommonCarousel) == 0x000000, "Member 'CommonWidgetCarouselNavBar_SetLinkedCarousel::CommonCarousel' has a wrong offset!");

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

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

// Function CommonUI.CommonWidgetSwitcher.HandleActiveWidgetDeactivated
// 0x0008 (0x0008 - 0x0000)
struct CommonWidgetSwitcher_HandleActiveWidgetDeactivated final
{
public:
	class UCommonActivatablePanel*                DeactivatedPanel;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonWidgetSwitcher_HandleActiveWidgetDeactivated) == 0x000008, "Wrong alignment on CommonWidgetSwitcher_HandleActiveWidgetDeactivated");
static_assert(sizeof(CommonWidgetSwitcher_HandleActiveWidgetDeactivated) == 0x000008, "Wrong size on CommonWidgetSwitcher_HandleActiveWidgetDeactivated");
static_assert(offsetof(CommonWidgetSwitcher_HandleActiveWidgetDeactivated, DeactivatedPanel) == 0x000000, "Member 'CommonWidgetSwitcher_HandleActiveWidgetDeactivated::DeactivatedPanel' has a wrong offset!");

// Function CommonUI.CommonWidgetSwitcher.SetActiveWidget_Advanced
// 0x0010 (0x0010 - 0x0000)
struct CommonWidgetSwitcher_SetActiveWidget_Advanced final
{
public:
	class UWidget*                                Widget;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          AttemptActivationChange;                           // 0x0008(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(CommonWidgetSwitcher_SetActiveWidget_Advanced) == 0x000008, "Wrong alignment on CommonWidgetSwitcher_SetActiveWidget_Advanced");
static_assert(sizeof(CommonWidgetSwitcher_SetActiveWidget_Advanced) == 0x000010, "Wrong size on CommonWidgetSwitcher_SetActiveWidget_Advanced");
static_assert(offsetof(CommonWidgetSwitcher_SetActiveWidget_Advanced, Widget) == 0x000000, "Member 'CommonWidgetSwitcher_SetActiveWidget_Advanced::Widget' has a wrong offset!");
static_assert(offsetof(CommonWidgetSwitcher_SetActiveWidget_Advanced, AttemptActivationChange) == 0x000008, "Member 'CommonWidgetSwitcher_SetActiveWidget_Advanced::AttemptActivationChange' has a wrong offset!");

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

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

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

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

// Function CommonUI.CommonWidgetStack.PushWidget
// 0x0008 (0x0008 - 0x0000)
struct CommonWidgetStack_PushWidget final
{
public:
	class UWidget*                                InWidget;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CommonWidgetStack_PushWidget) == 0x000008, "Wrong alignment on CommonWidgetStack_PushWidget");
static_assert(sizeof(CommonWidgetStack_PushWidget) == 0x000008, "Wrong size on CommonWidgetStack_PushWidget");
static_assert(offsetof(CommonWidgetStack_PushWidget, InWidget) == 0x000000, "Member 'CommonWidgetStack_PushWidget::InWidget' has a wrong offset!");

}

