#pragma once

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

// Package: CommonUI

#include "Basic.hpp"

#include "UMG_structs.hpp"
#include "UMG_classes.hpp"
#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"
#include "Engine_structs.hpp"
#include "Engine_classes.hpp"
#include "SlateCore_structs.hpp"
#include "CommonUI_structs.hpp"
#include "CommonInput_structs.hpp"


namespace SDK
{

// Class CommonUI.AnalogSlider
// 0x0010 (0x0500 - 0x04F0)
class UAnalogSlider final : public USlider
{
public:
	UMulticastDelegateProperty_                   OnAnalogCapture;                                   // 0x04F0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

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

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

// Class CommonUI.CommonBorder
// 0x0020 (0x0290 - 0x0270)
class UCommonBorder : public UBorder
{
public:
	TSubclassOf<class UCommonBorderStyle>         Style;                                             // 0x0270(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bReducePaddingBySafezone;                          // 0x0278(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_279[0x3];                                      // 0x0279(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMargin                                MinimumPadding;                                    // 0x027C(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_28C[0x4];                                      // 0x028C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetStyle(TSubclassOf<class UCommonBorderStyle> InStyle);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonBorder">();
	}
	static class UCommonBorder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonBorder>();
	}
};
static_assert(alignof(UCommonBorder) == 0x000008, "Wrong alignment on UCommonBorder");
static_assert(sizeof(UCommonBorder) == 0x000290, "Wrong size on UCommonBorder");
static_assert(offsetof(UCommonBorder, Style) == 0x000270, "Member 'UCommonBorder::Style' has a wrong offset!");
static_assert(offsetof(UCommonBorder, bReducePaddingBySafezone) == 0x000278, "Member 'UCommonBorder::bReducePaddingBySafezone' has a wrong offset!");
static_assert(offsetof(UCommonBorder, MinimumPadding) == 0x00027C, "Member 'UCommonBorder::MinimumPadding' has a wrong offset!");

// Class CommonUI.CommonActionWidget
// 0x0210 (0x0318 - 0x0108)
class UCommonActionWidget final : public UWidget
{
public:
	UMulticastDelegateProperty_                   OnInputMethodChanged;                              // 0x0108(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FDataTableRowHandle                    InputActionDataRow;                                // 0x0118(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPublic)
	struct FSlateBrush                            ProgressMaterialBrush;                             // 0x0128(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	class FName                                   ProgressMaterialParam;                             // 0x01B0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateBrush                            IconRimBrush;                                      // 0x01B8(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ProgressDynamicMaterial;                           // 0x0240(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_248[0xD0];                                     // 0x0248(0x00D0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnInputMethodChanged__DelegateSignature(bool bUsingGamepad);
	void SetIconRimBrush(const struct FSlateBrush& InIconRimBrush);
	void SetInputAction(const struct FDataTableRowHandle& InputActionRow);

	class FText GetDisplayText() const;
	struct FSlateBrush GetIcon() const;
	bool IsHeldAction() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonActionWidget">();
	}
	static class UCommonActionWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonActionWidget>();
	}
};
static_assert(alignof(UCommonActionWidget) == 0x000008, "Wrong alignment on UCommonActionWidget");
static_assert(sizeof(UCommonActionWidget) == 0x000318, "Wrong size on UCommonActionWidget");
static_assert(offsetof(UCommonActionWidget, OnInputMethodChanged) == 0x000108, "Member 'UCommonActionWidget::OnInputMethodChanged' has a wrong offset!");
static_assert(offsetof(UCommonActionWidget, InputActionDataRow) == 0x000118, "Member 'UCommonActionWidget::InputActionDataRow' has a wrong offset!");
static_assert(offsetof(UCommonActionWidget, ProgressMaterialBrush) == 0x000128, "Member 'UCommonActionWidget::ProgressMaterialBrush' has a wrong offset!");
static_assert(offsetof(UCommonActionWidget, ProgressMaterialParam) == 0x0001B0, "Member 'UCommonActionWidget::ProgressMaterialParam' has a wrong offset!");
static_assert(offsetof(UCommonActionWidget, IconRimBrush) == 0x0001B8, "Member 'UCommonActionWidget::IconRimBrush' has a wrong offset!");
static_assert(offsetof(UCommonActionWidget, ProgressDynamicMaterial) == 0x000240, "Member 'UCommonActionWidget::ProgressDynamicMaterial' has a wrong offset!");

// Class CommonUI.CommonUserWidget
// 0x0008 (0x0238 - 0x0230)
class UCommonUserWidget : public UUserWidget
{
public:
	bool                                          bConsumePointerInput;                              // 0x0230(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_231[0x7];                                      // 0x0231(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnTouchLeave(const struct FPointerEvent& TouchEvent);
	void SetConsumePointerInput(bool bInConsumePointerInput);

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

// Class CommonUI.CommonActivatablePanel
// 0x00E8 (0x0320 - 0x0238)
class UCommonActivatablePanel : public UCommonUserWidget
{
public:
	uint8                                         Pad_238[0x8];                                      // 0x0238(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnWidgetActivated;                                 // 0x0240(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnWidgetDeactivated;                               // 0x0250(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_260[0x40];                                     // 0x0260(0x0040)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bConsumeAllActions;                                // 0x02A0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bExposeActionsExternally;                          // 0x02A1(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bShouldBypassStack;                                // 0x02A2(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2A3[0x7D];                                     // 0x02A3(0x007D)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddInputActionHandler(class UDataTable* DataTable, class FName RowName, TDelegate<void(bool* bPassThrough)> CommitedEvent);
	void AddInputActionHandlerWithPopup(class UDataTable* DataTable, class FName RowName, TDelegate<void(bool* bPassThrough)> CommitedEvent, class UCommonPopupMenu* PopupMenu);
	void AddInputActionHandlerWithProgress(class UDataTable* DataTable, class FName RowName, TDelegate<void(bool* bPassThrough)> CommitedEvent, TDelegate<void(float HeldPercent)> ProgressEvent);
	void AddInputActionHandlerWithProgressPopup(class UDataTable* DataTable, class FName RowName, TDelegate<void(bool* bPassThrough)> CommitedEvent, TDelegate<void(float HeldPercent)> ProgressEvent, class UCommonPopupMenu* PopupMenu);
	void AddInputActionNoHandler(class UDataTable* DataTable, class FName RowName);
	void BeginIntro();
	void BeginOutro();
	void EndIntro();
	void EndOutro();
	void OnActivated();
	void OnAddedToActivationStack();
	void OnBeginIntro();
	void OnBeginOutro();
	void OnDeactivated();
	void OnInputModeChanged(bool bUsingGamepad);
	void OnRemovedFromActivationStack();
	void PopPanel();
	void RemoveAllInputActionHandlers();
	void RemoveInputActionHandler(const struct FDataTableRowHandle& InputActionRow);
	void SetActionHandlerState(const class UDataTable* DataTable, class FName RowName, EInputActionState State);
	void SetActionHandlerStateFromHandle(const struct FDataTableRowHandle& InputActionRow, EInputActionState State);
	void SetActionHandlerStateFromHandleWithDisabledCommitEvent(const struct FDataTableRowHandle& InputActionRow, EInputActionState State, TDelegate<void(bool* bPassThrough)> DisabledCommitEvent);
	void SetActionHandlerStateWithDisabledCommitEvent(class UDataTable* DataTable, class FName RowName, EInputActionState State, TDelegate<void(bool* bPassThrough)> DisabledCommitEvent);
	void SetInputActionHandler(const struct FDataTableRowHandle& InputActionRow, TDelegate<void(bool* bPassThrough)> CommitedEvent);
	void SetInputActionHandlerWithPopupMenu(const struct FDataTableRowHandle& InputActionRow, TDelegate<void(bool* bPassThrough)> CommitedEvent, class UCommonPopupMenu* PopupMenu);
	void SetInputActionHandlerWithProgress(const struct FDataTableRowHandle& InputActionRow, TDelegate<void(bool* bPassThrough)> CommitedEvent, TDelegate<void(float HeldPercent)> ProgressEvent);
	void SetInputActionHandlerWithProgressPopupMenu(const struct FDataTableRowHandle& InputActionRow, TDelegate<void(bool* bPassThrough)> CommitedEvent, TDelegate<void(float HeldPercent)> ProgressEvent, class UCommonPopupMenu* PopupMenu);

	bool GetInputActions(TArray<struct FCommonInputActionHandlerData>* InputActionDataRows) const;
	bool HasInputActionHandler(const struct FDataTableRowHandle& InputActionRow) const;
	bool IsActivated() const;
	bool IsInActivationStack() const;
	bool IsIntroed() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonActivatablePanel">();
	}
	static class UCommonActivatablePanel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonActivatablePanel>();
	}
};
static_assert(alignof(UCommonActivatablePanel) == 0x000008, "Wrong alignment on UCommonActivatablePanel");
static_assert(sizeof(UCommonActivatablePanel) == 0x000320, "Wrong size on UCommonActivatablePanel");
static_assert(offsetof(UCommonActivatablePanel, OnWidgetActivated) == 0x000240, "Member 'UCommonActivatablePanel::OnWidgetActivated' has a wrong offset!");
static_assert(offsetof(UCommonActivatablePanel, OnWidgetDeactivated) == 0x000250, "Member 'UCommonActivatablePanel::OnWidgetDeactivated' has a wrong offset!");
static_assert(offsetof(UCommonActivatablePanel, bConsumeAllActions) == 0x0002A0, "Member 'UCommonActivatablePanel::bConsumeAllActions' has a wrong offset!");
static_assert(offsetof(UCommonActivatablePanel, bExposeActionsExternally) == 0x0002A1, "Member 'UCommonActivatablePanel::bExposeActionsExternally' has a wrong offset!");
static_assert(offsetof(UCommonActivatablePanel, bShouldBypassStack) == 0x0002A2, "Member 'UCommonActivatablePanel::bShouldBypassStack' has a wrong offset!");

// Class CommonUI.CommonBorderStyle
// 0x0088 (0x00B0 - 0x0028)
class UCommonBorderStyle : public UObject
{
public:
	struct FSlateBrush                            Background;                                        // 0x0028(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)

public:
	void GetBackgroundBrush(struct FSlateBrush* Brush) const;

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

// Class CommonUI.CommonButtonStyle
// 0x0548 (0x0570 - 0x0028)
class UCommonButtonStyle : public UObject
{
public:
	bool                                          bSingleMaterial;                                   // 0x0028(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateBrush                            SingleMaterialBrush;                               // 0x0030(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FSlateBrush                            NormalBase;                                        // 0x00B8(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FSlateBrush                            NormalHovered;                                     // 0x0140(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FSlateBrush                            NormalPressed;                                     // 0x01C8(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FSlateBrush                            SelectedBase;                                      // 0x0250(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FSlateBrush                            SelectedHovered;                                   // 0x02D8(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FSlateBrush                            SelectedPressed;                                   // 0x0360(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FSlateBrush                            Disabled;                                          // 0x03E8(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FMargin                                ButtonPadding;                                     // 0x0470(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FMargin                                CustomPadding;                                     // 0x0480(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	int32                                         MinWidth;                                          // 0x0490(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MinHeight;                                         // 0x0494(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UCommonTextStyle>           NormalTextStyle;                                   // 0x0498(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UCommonTextStyle>           NormalHoveredTextStyle;                            // 0x04A0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UCommonTextStyle>           SelectedTextStyle;                                 // 0x04A8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UCommonTextStyle>           SelectedHoveredTextStyle;                          // 0x04B0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UCommonTextStyle>           DisabledTextStyle;                                 // 0x04B8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateSound                            PressedSlateSound;                                 // 0x04C0(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FCommonButtonStyleOptionalSlateSound   SelectedPressedSlateSound;                         // 0x04D8(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FCommonButtonStyleOptionalSlateSound   DisabledPressedSlateSound;                         // 0x04F8(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FSlateSound                            HoveredSlateSound;                                 // 0x0518(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FCommonButtonStyleOptionalSlateSound   SelectedHoveredSlateSound;                         // 0x0530(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
	struct FCommonButtonStyleOptionalSlateSound   DisabledHoveredSlateSound;                         // 0x0550(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)

public:
	void GetButtonPadding(struct FMargin* OutButtonPadding) const;
	void GetCustomPadding(struct FMargin* OutCustomPadding) const;
	void GetDisabledBrush(struct FSlateBrush* Brush) const;
	class UCommonTextStyle* GetDisabledTextStyle() const;
	void GetMaterialBrush(struct FSlateBrush* Brush) const;
	void GetNormalBaseBrush(struct FSlateBrush* Brush) const;
	void GetNormalHoveredBrush(struct FSlateBrush* Brush) const;
	class UCommonTextStyle* GetNormalHoveredTextStyle() const;
	void GetNormalPressedBrush(struct FSlateBrush* Brush) const;
	class UCommonTextStyle* GetNormalTextStyle() const;
	void GetSelectedBaseBrush(struct FSlateBrush* Brush) const;
	void GetSelectedHoveredBrush(struct FSlateBrush* Brush) const;
	class UCommonTextStyle* GetSelectedHoveredTextStyle() const;
	void GetSelectedPressedBrush(struct FSlateBrush* Brush) const;
	class UCommonTextStyle* GetSelectedTextStyle() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonButtonStyle">();
	}
	static class UCommonButtonStyle* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonButtonStyle>();
	}
};
static_assert(alignof(UCommonButtonStyle) == 0x000008, "Wrong alignment on UCommonButtonStyle");
static_assert(sizeof(UCommonButtonStyle) == 0x000570, "Wrong size on UCommonButtonStyle");
static_assert(offsetof(UCommonButtonStyle, bSingleMaterial) == 0x000028, "Member 'UCommonButtonStyle::bSingleMaterial' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, SingleMaterialBrush) == 0x000030, "Member 'UCommonButtonStyle::SingleMaterialBrush' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, NormalBase) == 0x0000B8, "Member 'UCommonButtonStyle::NormalBase' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, NormalHovered) == 0x000140, "Member 'UCommonButtonStyle::NormalHovered' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, NormalPressed) == 0x0001C8, "Member 'UCommonButtonStyle::NormalPressed' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, SelectedBase) == 0x000250, "Member 'UCommonButtonStyle::SelectedBase' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, SelectedHovered) == 0x0002D8, "Member 'UCommonButtonStyle::SelectedHovered' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, SelectedPressed) == 0x000360, "Member 'UCommonButtonStyle::SelectedPressed' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, Disabled) == 0x0003E8, "Member 'UCommonButtonStyle::Disabled' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, ButtonPadding) == 0x000470, "Member 'UCommonButtonStyle::ButtonPadding' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, CustomPadding) == 0x000480, "Member 'UCommonButtonStyle::CustomPadding' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, MinWidth) == 0x000490, "Member 'UCommonButtonStyle::MinWidth' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, MinHeight) == 0x000494, "Member 'UCommonButtonStyle::MinHeight' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, NormalTextStyle) == 0x000498, "Member 'UCommonButtonStyle::NormalTextStyle' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, NormalHoveredTextStyle) == 0x0004A0, "Member 'UCommonButtonStyle::NormalHoveredTextStyle' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, SelectedTextStyle) == 0x0004A8, "Member 'UCommonButtonStyle::SelectedTextStyle' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, SelectedHoveredTextStyle) == 0x0004B0, "Member 'UCommonButtonStyle::SelectedHoveredTextStyle' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, DisabledTextStyle) == 0x0004B8, "Member 'UCommonButtonStyle::DisabledTextStyle' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, PressedSlateSound) == 0x0004C0, "Member 'UCommonButtonStyle::PressedSlateSound' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, SelectedPressedSlateSound) == 0x0004D8, "Member 'UCommonButtonStyle::SelectedPressedSlateSound' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, DisabledPressedSlateSound) == 0x0004F8, "Member 'UCommonButtonStyle::DisabledPressedSlateSound' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, HoveredSlateSound) == 0x000518, "Member 'UCommonButtonStyle::HoveredSlateSound' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, SelectedHoveredSlateSound) == 0x000530, "Member 'UCommonButtonStyle::SelectedHoveredSlateSound' has a wrong offset!");
static_assert(offsetof(UCommonButtonStyle, DisabledHoveredSlateSound) == 0x000550, "Member 'UCommonButtonStyle::DisabledHoveredSlateSound' has a wrong offset!");

// Class CommonUI.CommonButtonInternal
// 0x0060 (0x0488 - 0x0428)
class UCommonButtonInternal final : public UButton
{
public:
	uint8                                         Pad_428[0x10];                                     // 0x0428(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnDoubleClicked;                                   // 0x0438(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_448[0x10];                                     // 0x0448(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MinWidth;                                          // 0x0458(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MinHeight;                                         // 0x045C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bButtonEnabled;                                    // 0x0460(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bInteractionEnabled;                               // 0x0461(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_462[0x26];                                     // 0x0462(0x0026)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonButtonInternal">();
	}
	static class UCommonButtonInternal* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonButtonInternal>();
	}
};
static_assert(alignof(UCommonButtonInternal) == 0x000008, "Wrong alignment on UCommonButtonInternal");
static_assert(sizeof(UCommonButtonInternal) == 0x000488, "Wrong size on UCommonButtonInternal");
static_assert(offsetof(UCommonButtonInternal, OnDoubleClicked) == 0x000438, "Member 'UCommonButtonInternal::OnDoubleClicked' has a wrong offset!");
static_assert(offsetof(UCommonButtonInternal, MinWidth) == 0x000458, "Member 'UCommonButtonInternal::MinWidth' has a wrong offset!");
static_assert(offsetof(UCommonButtonInternal, MinHeight) == 0x00045C, "Member 'UCommonButtonInternal::MinHeight' has a wrong offset!");
static_assert(offsetof(UCommonButtonInternal, bButtonEnabled) == 0x000460, "Member 'UCommonButtonInternal::bButtonEnabled' has a wrong offset!");
static_assert(offsetof(UCommonButtonInternal, bInteractionEnabled) == 0x000461, "Member 'UCommonButtonInternal::bInteractionEnabled' has a wrong offset!");

// Class CommonUI.CommonButton
// 0x08F8 (0x0B30 - 0x0238)
class UCommonButton : public UCommonUserWidget
{
public:
	int32                                         MinWidth;                                          // 0x0238(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MinHeight;                                         // 0x023C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UCommonButtonStyle>         Style;                                             // 0x0240(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bHideInputAction;                                  // 0x0248(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_249[0x7];                                      // 0x0249(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateSound                            PressedSlateSoundOverride;                         // 0x0250(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, NativeAccessSpecifierProtected)
	struct FSlateSound                            HoveredSlateSoundOverride;                         // 0x0268(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         bApplyAlphaOnDisable : 1;                          // 0x0280(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bSelectable : 1;                                   // 0x0280(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bShouldSelectUponReceivingFocus : 1;               // 0x0280(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bInteractableWhenSelected : 1;                     // 0x0280(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bToggleable : 1;                                   // 0x0280(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bDisplayInputActionWhenNotInteractable : 1;        // 0x0280(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bHideInputActionWithKeyboard : 1;                  // 0x0280(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bShouldUseFallbackDefaultInputAction : 1;          // 0x0280(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_281[0x1];                                      // 0x0281(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	EButtonClickMethod                            ClickMethod;                                       // 0x0282(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EButtonTouchMethod                            TouchMethod;                                       // 0x0283(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EButtonPressMethod                            PressMethod;                                       // 0x0284(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_285[0x3];                                      // 0x0285(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         InputPriority;                                     // 0x0288(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_28C[0x4];                                      // 0x028C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FDataTableRowHandle                    TriggeringInputAction;                             // 0x0290(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, ExposeOnSpawn, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A0[0x10];                                     // 0x02A0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnSelectedChanged;                                 // 0x02B0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   OnButtonClicked;                                   // 0x02C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   OnButtonDoubleClicked;                             // 0x02D0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   OnButtonHovered;                                   // 0x02E0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   OnButtonUnhovered;                                 // 0x02F0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	uint8                                         Pad_300[0x30];                                     // 0x0300(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
	class UCommonActionWidget*                    InputActionWidget;                                 // 0x0330(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UMaterialInstanceDynamic*               SingleMaterialStyleMID;                            // 0x0338(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FButtonStyle                           NormalStyle;                                       // 0x0340(0x0278)(NativeAccessSpecifierPrivate)
	struct FButtonStyle                           SelectedStyle;                                     // 0x05B8(0x0278)(NativeAccessSpecifierPrivate)
	struct FButtonStyle                           DisabledStyle;                                     // 0x0830(0x0278)(NativeAccessSpecifierPrivate)
	uint8                                         bStopDoubleClickPropagation : 1;                   // 0x0AA8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_AA9[0x87];                                     // 0x0AA9(0x0087)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void BP_OnClicked();
	void BP_OnDeselected();
	void BP_OnDisabled();
	void BP_OnDoubleClicked();
	void BP_OnEnabled();
	void BP_OnHovered();
	void BP_OnSelected();
	void BP_OnUnhovered();
	void ClearSelection();
	void DisableButtonWithReason(const class FText& DisabledReason);
	void HandleButtonClicked();
	void HandleButtonPressed();
	void HandleButtonReleased();
	void HandleFocusReceived();
	void HandleTriggeringActionCommited(bool* bPassThrough);
	void NativeOnActionComplete();
	void NativeOnActionProgress(float HeldPercent);
	void OnActionComplete();
	void OnActionProgress(float HeldPercent);
	void OnCurrentTextStyleChanged();
	void OnInputMethodChanged(ECommonInputType CurrentInputType);
	void OnTriggeredInputActionChanged(const struct FDataTableRowHandle& NewTriggeredAction);
	void SetClickMethod(EButtonClickMethod InClickMethod);
	void SetInputActionProgressMaterial(const struct FSlateBrush& InProgressMaterialBrush, const class FName& InProgressMaterialParam);
	void SetIsInteractableWhenSelected(bool bInInteractableWhenSelected);
	void SetIsInteractionEnabled(bool bInIsInteractionEnabled);
	void SetIsSelectable(bool bInIsSelectable);
	void SetIsSelected(bool InSelected, bool bGiveClickFeedback);
	void SetIsToggleable(bool bInIsToggleable);
	void SetMinDimensions(int32 InMinWidth, int32 InMinHeight);
	void SetPressMethod(EButtonPressMethod InPressMethod);
	void SetSelectedInternal(bool bInSelected, bool bAllowSound, bool bBroadcast);
	void SetShouldSelectUponReceivingFocus(bool bInShouldSelectUponReceivingFocus);
	void SetStyle(TSubclassOf<class UCommonButtonStyle> InStyle);
	void SetTouchMethod(EButtonTouchMethod InTouchMethod);
	void SetTriggeredInputAction(const struct FDataTableRowHandle& InputActionRow, class UCommonActivatablePanel* OldPanel);
	void SetTriggeringInputAction(const struct FDataTableRowHandle& InputActionRow);
	void StopDoubleClickPropagation();

	void GetCurrentButtonPadding(struct FMargin* OutButtonPadding) const;
	void GetCurrentCustomPadding(struct FMargin* OutCustomPadding) const;
	class UCommonTextStyle* GetCurrentTextStyle() const;
	TSubclassOf<class UCommonTextStyle> GetCurrentTextStyleClass() const;
	bool GetInputAction(struct FDataTableRowHandle* InputActionRow) const;
	bool GetSelected() const;
	bool GetShouldSelectUponReceivingFocus() const;
	class UMaterialInstanceDynamic* GetSingleMaterialStyleMID() const;
	class UCommonButtonStyle* GetStyle() const;
	bool IsInteractionEnabled() const;
	bool IsPressed() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonButton">();
	}
	static class UCommonButton* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonButton>();
	}
};
static_assert(alignof(UCommonButton) == 0x000008, "Wrong alignment on UCommonButton");
static_assert(sizeof(UCommonButton) == 0x000B30, "Wrong size on UCommonButton");
static_assert(offsetof(UCommonButton, MinWidth) == 0x000238, "Member 'UCommonButton::MinWidth' has a wrong offset!");
static_assert(offsetof(UCommonButton, MinHeight) == 0x00023C, "Member 'UCommonButton::MinHeight' has a wrong offset!");
static_assert(offsetof(UCommonButton, Style) == 0x000240, "Member 'UCommonButton::Style' has a wrong offset!");
static_assert(offsetof(UCommonButton, bHideInputAction) == 0x000248, "Member 'UCommonButton::bHideInputAction' has a wrong offset!");
static_assert(offsetof(UCommonButton, PressedSlateSoundOverride) == 0x000250, "Member 'UCommonButton::PressedSlateSoundOverride' has a wrong offset!");
static_assert(offsetof(UCommonButton, HoveredSlateSoundOverride) == 0x000268, "Member 'UCommonButton::HoveredSlateSoundOverride' has a wrong offset!");
static_assert(offsetof(UCommonButton, ClickMethod) == 0x000282, "Member 'UCommonButton::ClickMethod' has a wrong offset!");
static_assert(offsetof(UCommonButton, TouchMethod) == 0x000283, "Member 'UCommonButton::TouchMethod' has a wrong offset!");
static_assert(offsetof(UCommonButton, PressMethod) == 0x000284, "Member 'UCommonButton::PressMethod' has a wrong offset!");
static_assert(offsetof(UCommonButton, InputPriority) == 0x000288, "Member 'UCommonButton::InputPriority' has a wrong offset!");
static_assert(offsetof(UCommonButton, TriggeringInputAction) == 0x000290, "Member 'UCommonButton::TriggeringInputAction' has a wrong offset!");
static_assert(offsetof(UCommonButton, OnSelectedChanged) == 0x0002B0, "Member 'UCommonButton::OnSelectedChanged' has a wrong offset!");
static_assert(offsetof(UCommonButton, OnButtonClicked) == 0x0002C0, "Member 'UCommonButton::OnButtonClicked' has a wrong offset!");
static_assert(offsetof(UCommonButton, OnButtonDoubleClicked) == 0x0002D0, "Member 'UCommonButton::OnButtonDoubleClicked' has a wrong offset!");
static_assert(offsetof(UCommonButton, OnButtonHovered) == 0x0002E0, "Member 'UCommonButton::OnButtonHovered' has a wrong offset!");
static_assert(offsetof(UCommonButton, OnButtonUnhovered) == 0x0002F0, "Member 'UCommonButton::OnButtonUnhovered' has a wrong offset!");
static_assert(offsetof(UCommonButton, InputActionWidget) == 0x000330, "Member 'UCommonButton::InputActionWidget' has a wrong offset!");
static_assert(offsetof(UCommonButton, SingleMaterialStyleMID) == 0x000338, "Member 'UCommonButton::SingleMaterialStyleMID' has a wrong offset!");
static_assert(offsetof(UCommonButton, NormalStyle) == 0x000340, "Member 'UCommonButton::NormalStyle' has a wrong offset!");
static_assert(offsetof(UCommonButton, SelectedStyle) == 0x0005B8, "Member 'UCommonButton::SelectedStyle' has a wrong offset!");
static_assert(offsetof(UCommonButton, DisabledStyle) == 0x000830, "Member 'UCommonButton::DisabledStyle' has a wrong offset!");

// Class CommonUI.CommonWidgetGroupBase
// 0x0000 (0x0028 - 0x0028)
class UCommonWidgetGroupBase : public UObject
{
public:
	void AddWidget(class UWidget* InWidget);
	void RemoveAll();
	void RemoveWidget(class UWidget* InWidget);

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

// Class CommonUI.CommonButtonGroup
// 0x0070 (0x0098 - 0x0028)
class UCommonButtonGroup : public UCommonWidgetGroupBase
{
public:
	UMulticastDelegateProperty_                   OnSelectedButtonChanged;                           // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnHoveredButtonChanged;                            // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnButtonClicked;                                   // 0x0048(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnButtonDoubleClicked;                             // 0x0058(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnSelectionCleared;                                // 0x0068(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	bool                                          bSelectionRequired;                                // 0x0078(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_79[0x1F];                                      // 0x0079(0x001F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void DeselectAll();
	void OnButtonHovered(class UCommonButton* BaseButton);
	void OnButtonUnhovered(class UCommonButton* BaseButton);
	void OnHandleButtonClicked(class UCommonButton* BaseButton);
	void OnHandleButtonDoubleClicked(class UCommonButton* BaseButton);
	void OnSelectionStateChanged(class UCommonButton* BaseButton, bool bIsSelected);
	void SelectButtonAtIndex(int32 ButtonIndex);
	void SelectNextButton(bool bAllowWrap);
	void SelectPreviousButton(bool bAllowWrap);
	void SetSelectionRequired(bool bRequireSelection);

	int32 FindButtonIndex(const class UCommonButton* ButtonToFind) const;
	class UCommonButton* GetButtonAtIndex(int32 Param_Index) const;
	int32 GetButtonCount() const;
	int32 GetHoveredButtonIndex() const;
	int32 GetSelectedButtonIndex() const;
	bool HasAnyButtons() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonButtonGroup">();
	}
	static class UCommonButtonGroup* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonButtonGroup>();
	}
};
static_assert(alignof(UCommonButtonGroup) == 0x000008, "Wrong alignment on UCommonButtonGroup");
static_assert(sizeof(UCommonButtonGroup) == 0x000098, "Wrong size on UCommonButtonGroup");
static_assert(offsetof(UCommonButtonGroup, OnSelectedButtonChanged) == 0x000028, "Member 'UCommonButtonGroup::OnSelectedButtonChanged' has a wrong offset!");
static_assert(offsetof(UCommonButtonGroup, OnHoveredButtonChanged) == 0x000038, "Member 'UCommonButtonGroup::OnHoveredButtonChanged' has a wrong offset!");
static_assert(offsetof(UCommonButtonGroup, OnButtonClicked) == 0x000048, "Member 'UCommonButtonGroup::OnButtonClicked' has a wrong offset!");
static_assert(offsetof(UCommonButtonGroup, OnButtonDoubleClicked) == 0x000058, "Member 'UCommonButtonGroup::OnButtonDoubleClicked' has a wrong offset!");
static_assert(offsetof(UCommonButtonGroup, OnSelectionCleared) == 0x000068, "Member 'UCommonButtonGroup::OnSelectionCleared' has a wrong offset!");
static_assert(offsetof(UCommonButtonGroup, bSelectionRequired) == 0x000078, "Member 'UCommonButtonGroup::bSelectionRequired' has a wrong offset!");

// Class CommonUI.CommonCustomNavigation
// 0x0010 (0x0280 - 0x0270)
class UCommonCustomNavigation final : public UBorder
{
public:
	TDelegate<void(EUINavigation NavigationType)> OnNavigationEvent;                                 // 0x0270(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)

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

// Class CommonUI.CommonTextBlock
// 0x0020 (0x02C0 - 0x02A0)
class UCommonTextBlock : public UTextBlock
{
public:
	TSubclassOf<class UCommonTextStyle>           Style;                                             // 0x02A0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UCommonTextScrollStyle>     ScrollStyle;                                       // 0x02A8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B0[0x10];                                     // 0x02B0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ResetScrollState();
	void SetStyle(TSubclassOf<class UCommonTextStyle> InStyle);
	void SetWrapTextWidth(int32 InWrapTextAt);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonTextBlock">();
	}
	static class UCommonTextBlock* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonTextBlock>();
	}
};
static_assert(alignof(UCommonTextBlock) == 0x000008, "Wrong alignment on UCommonTextBlock");
static_assert(sizeof(UCommonTextBlock) == 0x0002C0, "Wrong size on UCommonTextBlock");
static_assert(offsetof(UCommonTextBlock, Style) == 0x0002A0, "Member 'UCommonTextBlock::Style' has a wrong offset!");
static_assert(offsetof(UCommonTextBlock, ScrollStyle) == 0x0002A8, "Member 'UCommonTextBlock::ScrollStyle' has a wrong offset!");

// Class CommonUI.CommonDateTimeTextBlock
// 0x0040 (0x0300 - 0x02C0)
class UCommonDateTimeTextBlock final : public UCommonTextBlock
{
public:
	uint8                                         Pad_2C0[0x40];                                     // 0x02C0(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetCountDownCompletionText(const class FText& InCompletionText);
	void SetDateTimeValue(const struct FDateTime& InDateTime, bool bShowAsCountdown);
	void SetTimespanValue(const struct FTimespan& InTimespan);

	struct FDateTime GetDateTime() const;

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

// Class CommonUI.CommonGlobalInputHandler
// 0x0048 (0x0070 - 0x0028)
class UCommonGlobalInputHandler final : public UObject
{
public:
	uint8                                         Pad_28[0x48];                                      // 0x0028(0x0048)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class CommonUI.CommonHierarchicalScrollBox
// 0x0000 (0x0868 - 0x0868)
class UCommonHierarchicalScrollBox final : public UScrollBox
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonHierarchicalScrollBox">();
	}
	static class UCommonHierarchicalScrollBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonHierarchicalScrollBox>();
	}
};
static_assert(alignof(UCommonHierarchicalScrollBox) == 0x000008, "Wrong alignment on UCommonHierarchicalScrollBox");
static_assert(sizeof(UCommonHierarchicalScrollBox) == 0x000868, "Wrong size on UCommonHierarchicalScrollBox");

// Class CommonUI.CommonInputManager
// 0x00E0 (0x0108 - 0x0028)
class UCommonInputManager final : public UObject
{
public:
	uint8                                         Pad_28[0x80];                                      // 0x0028(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
	TScriptInterface<class ICommonActionHandlerInterface> CurrentlyHeldActionInputHandler;                   // 0x00A8(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class UCommonActivatablePanel*>        ActivatablePanelStack;                             // 0x00B8(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	class UCommonGlobalInputHandler*              GlobalInputHandler;                                // 0x00C8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_D0[0x18];                                      // 0x00D0(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FOperation>                     Operations;                                        // 0x00E8(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	uint8                                         Pad_F8[0x10];                                      // 0x00F8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool GetAvailableInputActions(TArray<struct FCommonInputActionHandlerData>* AvailableInputActions);
	void PopActivatablePanel(class UCommonActivatablePanel* ActivatablePanel);
	void PushActivatablePanel(class UCommonActivatablePanel* ActivatablePanel, bool bIntroPanel, bool bOutroPanelBelow);
	void ResumeStartingOperationProcessing();
	void SetGlobalInputHandlerPriorityFilter(int32 InFilterPriority);
	bool StartListeningForExistingHeldAction(const struct FDataTableRowHandle& InputActionDataRow, const TDelegate<void()>& CompleteEvent, const TDelegate<void(float HeldPercent)>& ProgressEvent);
	bool StopListeningForExistingHeldAction(const struct FDataTableRowHandle& InputActionDataRow, const TDelegate<void()>& CompleteEvent, const TDelegate<void(float HeldPercent)>& ProgressEvent);
	void SuspendStartingOperationProcessing();

	int32 GetGlobalInputHandlerPriorityFilter() const;
	class UCommonActivatablePanel* GetTopPanel() const;
	bool IsInputSuspended() const;
	bool IsPanelOnStack(const class UCommonActivatablePanel* InPanel) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonInputManager">();
	}
	static class UCommonInputManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonInputManager>();
	}
};
static_assert(alignof(UCommonInputManager) == 0x000008, "Wrong alignment on UCommonInputManager");
static_assert(sizeof(UCommonInputManager) == 0x000108, "Wrong size on UCommonInputManager");
static_assert(offsetof(UCommonInputManager, CurrentlyHeldActionInputHandler) == 0x0000A8, "Member 'UCommonInputManager::CurrentlyHeldActionInputHandler' has a wrong offset!");
static_assert(offsetof(UCommonInputManager, ActivatablePanelStack) == 0x0000B8, "Member 'UCommonInputManager::ActivatablePanelStack' has a wrong offset!");
static_assert(offsetof(UCommonInputManager, GlobalInputHandler) == 0x0000C8, "Member 'UCommonInputManager::GlobalInputHandler' has a wrong offset!");
static_assert(offsetof(UCommonInputManager, Operations) == 0x0000E8, "Member 'UCommonInputManager::Operations' has a wrong offset!");

// Class CommonUI.CommonInputReflector
// 0x0030 (0x0268 - 0x0238)
class UCommonInputReflector : public UCommonUserWidget
{
public:
	TSubclassOf<class UCommonButton>              ButtonType;                                        // 0x0238(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UCommonButton*>                  ActiveButtons;                                     // 0x0240(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	TArray<class UCommonButton*>                  InactiveButtons;                                   // 0x0250(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	uint8                                         Pad_260[0x8];                                      // 0x0260(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnButtonAdded(class UCommonButton* AddedButton, const struct FCommonInputActionHandlerData& Data);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonInputReflector">();
	}
	static class UCommonInputReflector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonInputReflector>();
	}
};
static_assert(alignof(UCommonInputReflector) == 0x000008, "Wrong alignment on UCommonInputReflector");
static_assert(sizeof(UCommonInputReflector) == 0x000268, "Wrong size on UCommonInputReflector");
static_assert(offsetof(UCommonInputReflector, ButtonType) == 0x000238, "Member 'UCommonInputReflector::ButtonType' has a wrong offset!");
static_assert(offsetof(UCommonInputReflector, ActiveButtons) == 0x000240, "Member 'UCommonInputReflector::ActiveButtons' has a wrong offset!");
static_assert(offsetof(UCommonInputReflector, InactiveButtons) == 0x000250, "Member 'UCommonInputReflector::InactiveButtons' has a wrong offset!");

// Class CommonUI.CommonLazyImage
// 0x00C8 (0x02D8 - 0x0210)
class UCommonLazyImage : public UImage
{
public:
	struct FSlateBrush                            LoadingBackgroundBrush;                            // 0x0210(0x0088)(Edit, NativeAccessSpecifierPrivate)
	class FName                                   MaterialTextureParamName;                          // 0x0298(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   BP_OnLoadingStateChanged;                          // 0x02A0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2B0[0x28];                                     // 0x02B0(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetBrushFromLazyDisplayAsset(const TSoftObjectPtr<class UObject>& LazyObject, bool bMatchTextureSize);
	void SetBrushFromLazyMaterial(const TSoftObjectPtr<class UMaterialInterface>& LazyMaterial);
	void SetBrushFromLazyTexture(const TSoftObjectPtr<class UTexture2D>& LazyTexture, bool bMatchSize);
	void SetMaterialTextureParamName(class FName TextureParamName);

	bool IsLoading() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonLazyImage">();
	}
	static class UCommonLazyImage* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonLazyImage>();
	}
};
static_assert(alignof(UCommonLazyImage) == 0x000008, "Wrong alignment on UCommonLazyImage");
static_assert(sizeof(UCommonLazyImage) == 0x0002D8, "Wrong size on UCommonLazyImage");
static_assert(offsetof(UCommonLazyImage, LoadingBackgroundBrush) == 0x000210, "Member 'UCommonLazyImage::LoadingBackgroundBrush' has a wrong offset!");
static_assert(offsetof(UCommonLazyImage, MaterialTextureParamName) == 0x000298, "Member 'UCommonLazyImage::MaterialTextureParamName' has a wrong offset!");
static_assert(offsetof(UCommonLazyImage, BP_OnLoadingStateChanged) == 0x0002A0, "Member 'UCommonLazyImage::BP_OnLoadingStateChanged' has a wrong offset!");

// Class CommonUI.CommonLazyWidget
// 0x00F0 (0x01F8 - 0x0108)
class UCommonLazyWidget final : public UWidget
{
public:
	struct FSlateBrush                            LoadingBackgroundBrush;                            // 0x0108(0x0088)(Edit, NativeAccessSpecifierPrivate)
	class UUserWidget*                            Content;                                           // 0x0190(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_198[0x28];                                     // 0x0198(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   BP_OnLoadingStateChanged;                          // 0x01C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1D0[0x28];                                     // 0x01D0(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetLazyContent(const TSoftClassPtr<class UClass> SoftWidget);

	bool IsLoading() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonLazyWidget">();
	}
	static class UCommonLazyWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonLazyWidget>();
	}
};
static_assert(alignof(UCommonLazyWidget) == 0x000008, "Wrong alignment on UCommonLazyWidget");
static_assert(sizeof(UCommonLazyWidget) == 0x0001F8, "Wrong size on UCommonLazyWidget");
static_assert(offsetof(UCommonLazyWidget, LoadingBackgroundBrush) == 0x000108, "Member 'UCommonLazyWidget::LoadingBackgroundBrush' has a wrong offset!");
static_assert(offsetof(UCommonLazyWidget, Content) == 0x000190, "Member 'UCommonLazyWidget::Content' has a wrong offset!");
static_assert(offsetof(UCommonLazyWidget, BP_OnLoadingStateChanged) == 0x0001C0, "Member 'UCommonLazyWidget::BP_OnLoadingStateChanged' has a wrong offset!");

// Class CommonUI.CommonListView
// 0x0000 (0x0338 - 0x0338)
class UCommonListView : public UListView
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonListView">();
	}
	static class UCommonListView* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonListView>();
	}
};
static_assert(alignof(UCommonListView) == 0x000008, "Wrong alignment on UCommonListView");
static_assert(sizeof(UCommonListView) == 0x000338, "Wrong size on UCommonListView");

// Class CommonUI.LoadGuardSlot
// 0x0028 (0x0060 - 0x0038)
class ULoadGuardSlot final : public UPanelSlot
{
public:
	struct FMargin                                Padding;                                           // 0x0038(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPrivate)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0048(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0049(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_4A[0x16];                                      // 0x004A(0x0016)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetHorizontalAlignment(EHorizontalAlignment InHorizontalAlignment);
	void SetPadding(const struct FMargin& InPadding);
	void SetVerticalAlignment(EVerticalAlignment InVerticalAlignment);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LoadGuardSlot">();
	}
	static class ULoadGuardSlot* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULoadGuardSlot>();
	}
};
static_assert(alignof(ULoadGuardSlot) == 0x000008, "Wrong alignment on ULoadGuardSlot");
static_assert(sizeof(ULoadGuardSlot) == 0x000060, "Wrong size on ULoadGuardSlot");
static_assert(offsetof(ULoadGuardSlot, Padding) == 0x000038, "Member 'ULoadGuardSlot::Padding' has a wrong offset!");
static_assert(offsetof(ULoadGuardSlot, HorizontalAlignment) == 0x000048, "Member 'ULoadGuardSlot::HorizontalAlignment' has a wrong offset!");
static_assert(offsetof(ULoadGuardSlot, VerticalAlignment) == 0x000049, "Member 'ULoadGuardSlot::VerticalAlignment' has a wrong offset!");

// Class CommonUI.CommonLoadGuard
// 0x0110 (0x0230 - 0x0120)
class UCommonLoadGuard final : public UContentWidget
{
public:
	struct FSlateBrush                            LoadingBackgroundBrush;                            // 0x0120(0x0088)(Edit, NativeAccessSpecifierPrivate)
	EHorizontalAlignment                          ThrobberAlignment;                                 // 0x01A8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1A9[0x3];                                      // 0x01A9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMargin                                ThrobberPadding;                                   // 0x01AC(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1BC[0x4];                                      // 0x01BC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FText                                   LoadingText;                                       // 0x01C0(0x0018)(Edit, NativeAccessSpecifierPrivate)
	TSubclassOf<class UCommonTextStyle>           TextStyle;                                         // 0x01D8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   BP_OnLoadingStateChanged;                          // 0x01E0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	struct FSoftObjectPath                        SpinnerMaterialPath;                               // 0x01F0(0x0018)(ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_208[0x28];                                     // 0x0208(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void BP_GuardAndLoadAsset(const TSoftObjectPtr<class UObject>& InLazyAsset, const TDelegate<void(class UObject* Object)>& OnAssetLoaded);
	void OnAssetLoaded__DelegateSignature(class UObject* Object);
	void SetIsLoading(bool bInIsLoading);
	void SetLoadingText(const class FText& InLoadingText);

	bool IsLoading() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonLoadGuard">();
	}
	static class UCommonLoadGuard* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonLoadGuard>();
	}
};
static_assert(alignof(UCommonLoadGuard) == 0x000008, "Wrong alignment on UCommonLoadGuard");
static_assert(sizeof(UCommonLoadGuard) == 0x000230, "Wrong size on UCommonLoadGuard");
static_assert(offsetof(UCommonLoadGuard, LoadingBackgroundBrush) == 0x000120, "Member 'UCommonLoadGuard::LoadingBackgroundBrush' has a wrong offset!");
static_assert(offsetof(UCommonLoadGuard, ThrobberAlignment) == 0x0001A8, "Member 'UCommonLoadGuard::ThrobberAlignment' has a wrong offset!");
static_assert(offsetof(UCommonLoadGuard, ThrobberPadding) == 0x0001AC, "Member 'UCommonLoadGuard::ThrobberPadding' has a wrong offset!");
static_assert(offsetof(UCommonLoadGuard, LoadingText) == 0x0001C0, "Member 'UCommonLoadGuard::LoadingText' has a wrong offset!");
static_assert(offsetof(UCommonLoadGuard, TextStyle) == 0x0001D8, "Member 'UCommonLoadGuard::TextStyle' has a wrong offset!");
static_assert(offsetof(UCommonLoadGuard, BP_OnLoadingStateChanged) == 0x0001E0, "Member 'UCommonLoadGuard::BP_OnLoadingStateChanged' has a wrong offset!");
static_assert(offsetof(UCommonLoadGuard, SpinnerMaterialPath) == 0x0001F0, "Member 'UCommonLoadGuard::SpinnerMaterialPath' has a wrong offset!");

// Class CommonUI.CommonNumericTextBlock
// 0x0080 (0x0340 - 0x02C0)
class UCommonNumericTextBlock : public UCommonTextBlock
{
public:
	UMulticastDelegateProperty_                   OnOutroEvent;                                      // 0x02C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnInterpolationEndedEvent;                         // 0x02D0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	float                                         CurrentNumericValue;                               // 0x02E0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECommonNumericType                            NumericType;                                       // 0x02E4(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2E5[0x3];                                      // 0x02E5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FCommonNumberFormattingOptions         FormattingSpecification;                           // 0x02E8(0x0014)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPublic)
	float                                         EaseOutInterpolationExponent;                      // 0x02FC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InterpolationUpdateInterval;                       // 0x0300(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PostInterpolationShrinkDuration;                   // 0x0304(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          PerformSizeInterpolation;                          // 0x0308(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsPercentage;                                      // 0x0309(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_30A[0x36];                                     // 0x030A(0x0036)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void InterpolateToValue(const float TargetValue, float MaximumInterpolationDuration, float MinimumChangeRate, float OutroOffset);
	void OnInterpolationEnded__DelegateSignature(class UCommonNumericTextBlock* NumericTextBlock, const bool HadCompleted);
	void OnOutro__DelegateSignature(class UCommonNumericTextBlock* NumericTextBlock);
	void SetCurrentValue(const float NewValue);
	void SetNumericType(ECommonNumericType InNumericType);

	float GetTargetValue() const;
	bool IsInterpolatingNumericValue() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonNumericTextBlock">();
	}
	static class UCommonNumericTextBlock* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonNumericTextBlock>();
	}
};
static_assert(alignof(UCommonNumericTextBlock) == 0x000008, "Wrong alignment on UCommonNumericTextBlock");
static_assert(sizeof(UCommonNumericTextBlock) == 0x000340, "Wrong size on UCommonNumericTextBlock");
static_assert(offsetof(UCommonNumericTextBlock, OnOutroEvent) == 0x0002C0, "Member 'UCommonNumericTextBlock::OnOutroEvent' has a wrong offset!");
static_assert(offsetof(UCommonNumericTextBlock, OnInterpolationEndedEvent) == 0x0002D0, "Member 'UCommonNumericTextBlock::OnInterpolationEndedEvent' has a wrong offset!");
static_assert(offsetof(UCommonNumericTextBlock, CurrentNumericValue) == 0x0002E0, "Member 'UCommonNumericTextBlock::CurrentNumericValue' has a wrong offset!");
static_assert(offsetof(UCommonNumericTextBlock, NumericType) == 0x0002E4, "Member 'UCommonNumericTextBlock::NumericType' has a wrong offset!");
static_assert(offsetof(UCommonNumericTextBlock, FormattingSpecification) == 0x0002E8, "Member 'UCommonNumericTextBlock::FormattingSpecification' has a wrong offset!");
static_assert(offsetof(UCommonNumericTextBlock, EaseOutInterpolationExponent) == 0x0002FC, "Member 'UCommonNumericTextBlock::EaseOutInterpolationExponent' has a wrong offset!");
static_assert(offsetof(UCommonNumericTextBlock, InterpolationUpdateInterval) == 0x000300, "Member 'UCommonNumericTextBlock::InterpolationUpdateInterval' has a wrong offset!");
static_assert(offsetof(UCommonNumericTextBlock, PostInterpolationShrinkDuration) == 0x000304, "Member 'UCommonNumericTextBlock::PostInterpolationShrinkDuration' has a wrong offset!");
static_assert(offsetof(UCommonNumericTextBlock, PerformSizeInterpolation) == 0x000308, "Member 'UCommonNumericTextBlock::PerformSizeInterpolation' has a wrong offset!");
static_assert(offsetof(UCommonNumericTextBlock, IsPercentage) == 0x000309, "Member 'UCommonNumericTextBlock::IsPercentage' has a wrong offset!");

// Class CommonUI.CommonPoolableWidgetInterface
// 0x0000 (0x0028 - 0x0028)
class ICommonPoolableWidgetInterface final : public IInterface
{
public:
	void OnAcquireFromPool();
	void OnReleaseToPool();

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

// Class CommonUI.CommonPopupButton
// 0x0010 (0x0B40 - 0x0B30)
class UCommonPopupButton : public UCommonButton
{
public:
	class UMenuAnchor*                            PopupMenuAnchor;                                   // 0x0B30(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCommonPopupMenu*                       PopupMenu;                                         // 0x0B38(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	class UWidget* GetMenuAnchorWidget();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonPopupButton">();
	}
	static class UCommonPopupButton* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonPopupButton>();
	}
};
static_assert(alignof(UCommonPopupButton) == 0x000008, "Wrong alignment on UCommonPopupButton");
static_assert(sizeof(UCommonPopupButton) == 0x000B40, "Wrong size on UCommonPopupButton");
static_assert(offsetof(UCommonPopupButton, PopupMenuAnchor) == 0x000B30, "Member 'UCommonPopupButton::PopupMenuAnchor' has a wrong offset!");
static_assert(offsetof(UCommonPopupButton, PopupMenu) == 0x000B38, "Member 'UCommonPopupButton::PopupMenu' has a wrong offset!");

// Class CommonUI.CommonPopupMenu
// 0x0018 (0x0338 - 0x0320)
class UCommonPopupMenu : public UCommonActivatablePanel
{
public:
	bool                                          bUseInputStack;                                    // 0x0320(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_321[0x3];                                      // 0x0321(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class UMenuAnchor>             OwningMenuAnchor;                                  // 0x0324(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TWeakObjectPtr<class UObject>                 ContextProvidingObject;                            // 0x032C(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_334[0x4];                                      // 0x0334(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void HandlePostDifferentContextProviderSet();
	void HandlePreDifferentContextProviderSet();
	void OnIsOpenChanged(bool IsOpen);
	void RequestClose();
	void SetContextProvider(const class UObject* Param_ContextProvidingObject);
	void SetOwningMenuAnchor(const class UMenuAnchor* MenuAnchor);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonPopupMenu">();
	}
	static class UCommonPopupMenu* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonPopupMenu>();
	}
};
static_assert(alignof(UCommonPopupMenu) == 0x000008, "Wrong alignment on UCommonPopupMenu");
static_assert(sizeof(UCommonPopupMenu) == 0x000338, "Wrong size on UCommonPopupMenu");
static_assert(offsetof(UCommonPopupMenu, bUseInputStack) == 0x000320, "Member 'UCommonPopupMenu::bUseInputStack' has a wrong offset!");
static_assert(offsetof(UCommonPopupMenu, OwningMenuAnchor) == 0x000324, "Member 'UCommonPopupMenu::OwningMenuAnchor' has a wrong offset!");
static_assert(offsetof(UCommonPopupMenu, ContextProvidingObject) == 0x00032C, "Member 'UCommonPopupMenu::ContextProvidingObject' has a wrong offset!");

// Class CommonUI.CommonRotator
// 0x0040 (0x0B70 - 0x0B30)
class UCommonRotator : public UCommonButton
{
public:
	uint8                                         Pad_B30[0x10];                                     // 0x0B30(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnRotated;                                         // 0x0B40(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	class UCommonTextBlock*                       MyText;                                            // 0x0B50(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_B58[0x18];                                     // 0x0B58(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void PopulateTextLabels(const TArray<class FText>& Labels);
	void SetSelectedItem(int32 InValue);
	void ShiftTextLeft();
	void ShiftTextRight();

	int32 GetSelectedIndex() const;
	class FText GetSelectedText() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonRotator">();
	}
	static class UCommonRotator* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonRotator>();
	}
};
static_assert(alignof(UCommonRotator) == 0x000008, "Wrong alignment on UCommonRotator");
static_assert(sizeof(UCommonRotator) == 0x000B70, "Wrong size on UCommonRotator");
static_assert(offsetof(UCommonRotator, OnRotated) == 0x000B40, "Member 'UCommonRotator::OnRotated' has a wrong offset!");
static_assert(offsetof(UCommonRotator, MyText) == 0x000B50, "Member 'UCommonRotator::MyText' has a wrong offset!");

// Class CommonUI.CommonTabListWidget
// 0x00C8 (0x0300 - 0x0238)
class UCommonTabListWidget : public UCommonUserWidget
{
public:
	UMulticastDelegateProperty_                   OnTabSelected;                                     // 0x0238(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnTabButtonCreated;                                // 0x0248(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnTabButtonRemoved;                                // 0x0258(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FDataTableRowHandle                    NextTabInputActionData;                            // 0x0268(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, NativeAccessSpecifierProtected)
	struct FDataTableRowHandle                    PreviousTabInputActionData;                        // 0x0278(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, NativeAccessSpecifierProtected)
	bool                                          bAutoListenForInput;                               // 0x0288(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_289[0x3];                                      // 0x0289(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class UCommonWidgetSwitcher>   LinkedSwitcher;                                    // 0x028C(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_294[0x4];                                      // 0x0294(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<class FName, struct FCommonRegisteredTabInfo> RegisteredTabsByID;                                // 0x0298(0x0050)(ZeroConstructor, Transient, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	class UCommonButtonGroup*                     TabButtonGroup;                                    // 0x02E8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2F0[0x10];                                     // 0x02F0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void DisableTabWithReason(class FName TabNameID, const class FText& Reason);
	class UCommonButton* GetTabButtonByID(class FName TabNameID);
	void HandleNextTabInputAction(bool* bPassThrough);
	void HandlePostLinkedSwitcherChanged_BP();
	void HandlePreLinkedSwitcherChanged_BP();
	void HandlePreviousTabInputAction(bool* bPassThrough);
	void HandleTabButtonSelected(class UCommonButton* SelectedTabButton, int32 ButtonIndex);
	void HandleTabCreated(class FName TabNameID, class UCommonButton* TabButton);
	void HandleTabRemoved(class FName TabNameID, class UCommonButton* TabButton);
	void OnTabButtonCreated__DelegateSignature(class FName TabId, class UCommonButton* TabButton);
	void OnTabButtonRemoved__DelegateSignature(class FName TabId, class UCommonButton* TabButton);
	void OnTabSelected__DelegateSignature(class FName TabId);
	bool RegisterTab(class FName TabNameID, TSubclassOf<class UCommonButton> ButtonWidgetType, class UWidget* ContentWidget);
	void RemoveAllTabs();
	bool RemoveTab(class FName TabNameID);
	bool SelectTabByID(class FName TabNameID, bool bSuppressClickFeedback);
	void SetLinkedSwitcher(class UCommonWidgetSwitcher* CommonSwitcher);
	void SetListeningForInput(bool bShouldListen);
	void SetTabEnabled(class FName TabNameID, bool bEnable);
	void SetTabInteractionEnabled(class FName TabNameID, bool bEnable);
	void SetTabVisibility(class FName TabNameID, ESlateVisibility NewVisibility);

	class FName GetActiveTab() const;
	class UCommonWidgetSwitcher* GetLinkedSwitcher() const;
	class FName GetSelectedTabId() const;
	int32 GetTabCount() const;
	class FName GetTabIdAtIndex(int32 Param_Index) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonTabListWidget">();
	}
	static class UCommonTabListWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonTabListWidget>();
	}
};
static_assert(alignof(UCommonTabListWidget) == 0x000008, "Wrong alignment on UCommonTabListWidget");
static_assert(sizeof(UCommonTabListWidget) == 0x000300, "Wrong size on UCommonTabListWidget");
static_assert(offsetof(UCommonTabListWidget, OnTabSelected) == 0x000238, "Member 'UCommonTabListWidget::OnTabSelected' has a wrong offset!");
static_assert(offsetof(UCommonTabListWidget, OnTabButtonCreated) == 0x000248, "Member 'UCommonTabListWidget::OnTabButtonCreated' has a wrong offset!");
static_assert(offsetof(UCommonTabListWidget, OnTabButtonRemoved) == 0x000258, "Member 'UCommonTabListWidget::OnTabButtonRemoved' has a wrong offset!");
static_assert(offsetof(UCommonTabListWidget, NextTabInputActionData) == 0x000268, "Member 'UCommonTabListWidget::NextTabInputActionData' has a wrong offset!");
static_assert(offsetof(UCommonTabListWidget, PreviousTabInputActionData) == 0x000278, "Member 'UCommonTabListWidget::PreviousTabInputActionData' has a wrong offset!");
static_assert(offsetof(UCommonTabListWidget, bAutoListenForInput) == 0x000288, "Member 'UCommonTabListWidget::bAutoListenForInput' has a wrong offset!");
static_assert(offsetof(UCommonTabListWidget, LinkedSwitcher) == 0x00028C, "Member 'UCommonTabListWidget::LinkedSwitcher' has a wrong offset!");
static_assert(offsetof(UCommonTabListWidget, RegisteredTabsByID) == 0x000298, "Member 'UCommonTabListWidget::RegisteredTabsByID' has a wrong offset!");
static_assert(offsetof(UCommonTabListWidget, TabButtonGroup) == 0x0002E8, "Member 'UCommonTabListWidget::TabButtonGroup' has a wrong offset!");

// Class CommonUI.CommonTextStyle
// 0x0120 (0x0148 - 0x0028)
class UCommonTextStyle : public UObject
{
public:
	struct FSlateFontInfo                         Font;                                              // 0x0028(0x0050)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           Color;                                             // 0x0078(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUsesDropShadow;                                   // 0x0088(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_89[0x3];                                       // 0x0089(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              ShadowOffset;                                      // 0x008C(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ShadowColor;                                       // 0x0094(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMargin                                Margin;                                            // 0x00A4(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_B4[0x4];                                       // 0x00B4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateBrush                            StrikeBrush;                                       // 0x00B8(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	float                                         LineHeightPercentage;                              // 0x0140(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_144[0x4];                                      // 0x0144(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void GetColor(struct FLinearColor* OutColor) const;
	void GetFont(struct FSlateFontInfo* OutFont) const;
	float GetLineHeightPercentage() const;
	void GetMargin(struct FMargin* OutMargin) const;
	void GetShadowColor(struct FLinearColor* OutColor) const;
	void GetShadowOffset(struct FVector2D* OutShadowOffset) const;
	void GetStrikeBrush(struct FSlateBrush* OutStrikeBrush) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonTextStyle">();
	}
	static class UCommonTextStyle* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonTextStyle>();
	}
};
static_assert(alignof(UCommonTextStyle) == 0x000008, "Wrong alignment on UCommonTextStyle");
static_assert(sizeof(UCommonTextStyle) == 0x000148, "Wrong size on UCommonTextStyle");
static_assert(offsetof(UCommonTextStyle, Font) == 0x000028, "Member 'UCommonTextStyle::Font' has a wrong offset!");
static_assert(offsetof(UCommonTextStyle, Color) == 0x000078, "Member 'UCommonTextStyle::Color' has a wrong offset!");
static_assert(offsetof(UCommonTextStyle, bUsesDropShadow) == 0x000088, "Member 'UCommonTextStyle::bUsesDropShadow' has a wrong offset!");
static_assert(offsetof(UCommonTextStyle, ShadowOffset) == 0x00008C, "Member 'UCommonTextStyle::ShadowOffset' has a wrong offset!");
static_assert(offsetof(UCommonTextStyle, ShadowColor) == 0x000094, "Member 'UCommonTextStyle::ShadowColor' has a wrong offset!");
static_assert(offsetof(UCommonTextStyle, Margin) == 0x0000A4, "Member 'UCommonTextStyle::Margin' has a wrong offset!");
static_assert(offsetof(UCommonTextStyle, StrikeBrush) == 0x0000B8, "Member 'UCommonTextStyle::StrikeBrush' has a wrong offset!");
static_assert(offsetof(UCommonTextStyle, LineHeightPercentage) == 0x000140, "Member 'UCommonTextStyle::LineHeightPercentage' has a wrong offset!");

// Class CommonUI.CommonTextScrollStyle
// 0x0018 (0x0040 - 0x0028)
class UCommonTextScrollStyle : public UObject
{
public:
	float                                         Speed;                                             // 0x0028(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StartDelay;                                        // 0x002C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         EndDelay;                                          // 0x0030(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeInDelay;                                       // 0x0034(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeOutDelay;                                      // 0x0038(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonTextScrollStyle">();
	}
	static class UCommonTextScrollStyle* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonTextScrollStyle>();
	}
};
static_assert(alignof(UCommonTextScrollStyle) == 0x000008, "Wrong alignment on UCommonTextScrollStyle");
static_assert(sizeof(UCommonTextScrollStyle) == 0x000040, "Wrong size on UCommonTextScrollStyle");
static_assert(offsetof(UCommonTextScrollStyle, Speed) == 0x000028, "Member 'UCommonTextScrollStyle::Speed' has a wrong offset!");
static_assert(offsetof(UCommonTextScrollStyle, StartDelay) == 0x00002C, "Member 'UCommonTextScrollStyle::StartDelay' has a wrong offset!");
static_assert(offsetof(UCommonTextScrollStyle, EndDelay) == 0x000030, "Member 'UCommonTextScrollStyle::EndDelay' has a wrong offset!");
static_assert(offsetof(UCommonTextScrollStyle, FadeInDelay) == 0x000034, "Member 'UCommonTextScrollStyle::FadeInDelay' has a wrong offset!");
static_assert(offsetof(UCommonTextScrollStyle, FadeOutDelay) == 0x000038, "Member 'UCommonTextScrollStyle::FadeOutDelay' has a wrong offset!");

// Class CommonUI.CommonTileView
// 0x0000 (0x0358 - 0x0358)
class UCommonTileView : public UTileView
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonTileView">();
	}
	static class UCommonTileView* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonTileView>();
	}
};
static_assert(alignof(UCommonTileView) == 0x000008, "Wrong alignment on UCommonTileView");
static_assert(sizeof(UCommonTileView) == 0x000358, "Wrong size on UCommonTileView");

// Class CommonUI.CommonTreeView
// 0x0000 (0x0390 - 0x0390)
class UCommonTreeView final : public UTreeView
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonTreeView">();
	}
	static class UCommonTreeView* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonTreeView>();
	}
};
static_assert(alignof(UCommonTreeView) == 0x000008, "Wrong alignment on UCommonTreeView");
static_assert(sizeof(UCommonTreeView) == 0x000390, "Wrong size on UCommonTreeView");

// Class CommonUI.CommonUIEditorSettings
// 0x0080 (0x00A8 - 0x0028)
class UCommonUIEditorSettings final : public UObject
{
public:
	TSoftClassPtr<class UClass>                   TemplateTextStyle;                                 // 0x0028(0x0028)(Edit, Config, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSoftClassPtr<class UClass>                   TemplateButtonStyle;                               // 0x0050(0x0028)(Edit, Config, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSoftClassPtr<class UClass>                   TemplateBorderStyle;                               // 0x0078(0x0028)(Edit, Config, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_A0[0x8];                                       // 0x00A0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonUIEditorSettings">();
	}
	static class UCommonUIEditorSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonUIEditorSettings>();
	}
};
static_assert(alignof(UCommonUIEditorSettings) == 0x000008, "Wrong alignment on UCommonUIEditorSettings");
static_assert(sizeof(UCommonUIEditorSettings) == 0x0000A8, "Wrong size on UCommonUIEditorSettings");
static_assert(offsetof(UCommonUIEditorSettings, TemplateTextStyle) == 0x000028, "Member 'UCommonUIEditorSettings::TemplateTextStyle' has a wrong offset!");
static_assert(offsetof(UCommonUIEditorSettings, TemplateButtonStyle) == 0x000050, "Member 'UCommonUIEditorSettings::TemplateButtonStyle' has a wrong offset!");
static_assert(offsetof(UCommonUIEditorSettings, TemplateBorderStyle) == 0x000078, "Member 'UCommonUIEditorSettings::TemplateBorderStyle' has a wrong offset!");

// Class CommonUI.CommonUILibrary
// 0x0000 (0x0028 - 0x0028)
class UCommonUILibrary final : public UBlueprintFunctionLibrary
{
public:
	static class UWidget* FindParentWidgetOfType(class UWidget* StartingWidget, TSubclassOf<class UWidget> Type);

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

// Class CommonUI.CommonUISettings
// 0x00F8 (0x0120 - 0x0028)
class UCommonUISettings final : public UObject
{
public:
	bool                                          bAutoLoadData;                                     // 0x0028(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TSoftObjectPtr<class UObject>                 DefaultImageResourceObject;                        // 0x0030(0x0028)(Edit, Config, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSoftObjectPtr<class UMaterialInterface>      DefaultThrobberMaterial;                           // 0x0058(0x0028)(Edit, Config, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_80[0x8];                                       // 0x0080(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UObject*                                DefaultImageResourceObjectInstance;                // 0x0088(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UMaterialInterface*                     DefaultThrobberMaterialInstance;                   // 0x0090(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FSlateBrush                            DefaultThrobberBrush;                              // 0x0098(0x0088)(Transient, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonUISettings">();
	}
	static class UCommonUISettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonUISettings>();
	}
};
static_assert(alignof(UCommonUISettings) == 0x000008, "Wrong alignment on UCommonUISettings");
static_assert(sizeof(UCommonUISettings) == 0x000120, "Wrong size on UCommonUISettings");
static_assert(offsetof(UCommonUISettings, bAutoLoadData) == 0x000028, "Member 'UCommonUISettings::bAutoLoadData' has a wrong offset!");
static_assert(offsetof(UCommonUISettings, DefaultImageResourceObject) == 0x000030, "Member 'UCommonUISettings::DefaultImageResourceObject' has a wrong offset!");
static_assert(offsetof(UCommonUISettings, DefaultThrobberMaterial) == 0x000058, "Member 'UCommonUISettings::DefaultThrobberMaterial' has a wrong offset!");
static_assert(offsetof(UCommonUISettings, DefaultImageResourceObjectInstance) == 0x000088, "Member 'UCommonUISettings::DefaultImageResourceObjectInstance' has a wrong offset!");
static_assert(offsetof(UCommonUISettings, DefaultThrobberMaterialInstance) == 0x000090, "Member 'UCommonUISettings::DefaultThrobberMaterialInstance' has a wrong offset!");
static_assert(offsetof(UCommonUISettings, DefaultThrobberBrush) == 0x000098, "Member 'UCommonUISettings::DefaultThrobberBrush' has a wrong offset!");

// Class CommonUI.CommonUISubsystem
// 0x0050 (0x0078 - 0x0028)
class UCommonUISubsystem final : public UGameInstanceSubsystem
{
public:
	UMulticastDelegateProperty_                   OnInputMethodChanged;                              // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_38[0x18];                                      // 0x0038(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnInputSuspensionChanged;                          // 0x0050(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_60[0x10];                                      // 0x0060(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class UCommonInputManager*                    CommonInputManager;                                // 0x0070(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void InputMethodChangedDelegate__DelegateSignature(bool bUsingGamepad);
	void InputSuspensionChanged__DelegateSignature(bool bInputSuspended);

	struct FSlateBrush GetInputActionButtonIcon(const struct FDataTableRowHandle& InputActionRowHandle, ECommonInputType InputType, ECommonGamepadType GamepadType) const;
	class UCommonInputManager* GetInputManager() const;

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

// Class CommonUI.CommonVisibilityWidget
// 0x0010 (0x02A0 - 0x0290)
class UCommonVisibilityWidget final : public UCommonBorder
{
public:
	bool                                          bShowForGamepad;                                   // 0x0290(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowForMouseAndKeyboard;                          // 0x0291(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowForTouch;                                     // 0x0292(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowForPC;                                        // 0x0293(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowForMac;                                       // 0x0294(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowForPS4;                                       // 0x0295(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowForXBox;                                      // 0x0296(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowForIOS;                                       // 0x0297(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowForAndroid;                                   // 0x0298(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowForErebus;                                    // 0x0299(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESlateVisibility                              VisibleType;                                       // 0x029A(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESlateVisibility                              HiddenType;                                        // 0x029B(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29C[0x4];                                      // 0x029C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonVisibilityWidget">();
	}
	static class UCommonVisibilityWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonVisibilityWidget>();
	}
};
static_assert(alignof(UCommonVisibilityWidget) == 0x000008, "Wrong alignment on UCommonVisibilityWidget");
static_assert(sizeof(UCommonVisibilityWidget) == 0x0002A0, "Wrong size on UCommonVisibilityWidget");
static_assert(offsetof(UCommonVisibilityWidget, bShowForGamepad) == 0x000290, "Member 'UCommonVisibilityWidget::bShowForGamepad' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, bShowForMouseAndKeyboard) == 0x000291, "Member 'UCommonVisibilityWidget::bShowForMouseAndKeyboard' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, bShowForTouch) == 0x000292, "Member 'UCommonVisibilityWidget::bShowForTouch' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, bShowForPC) == 0x000293, "Member 'UCommonVisibilityWidget::bShowForPC' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, bShowForMac) == 0x000294, "Member 'UCommonVisibilityWidget::bShowForMac' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, bShowForPS4) == 0x000295, "Member 'UCommonVisibilityWidget::bShowForPS4' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, bShowForXBox) == 0x000296, "Member 'UCommonVisibilityWidget::bShowForXBox' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, bShowForIOS) == 0x000297, "Member 'UCommonVisibilityWidget::bShowForIOS' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, bShowForAndroid) == 0x000298, "Member 'UCommonVisibilityWidget::bShowForAndroid' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, bShowForErebus) == 0x000299, "Member 'UCommonVisibilityWidget::bShowForErebus' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, VisibleType) == 0x00029A, "Member 'UCommonVisibilityWidget::VisibleType' has a wrong offset!");
static_assert(offsetof(UCommonVisibilityWidget, HiddenType) == 0x00029B, "Member 'UCommonVisibilityWidget::HiddenType' has a wrong offset!");

// Class CommonUI.CommonWidgetCarousel
// 0x0040 (0x0160 - 0x0120)
class UCommonWidgetCarousel final : public UPanelWidget
{
public:
	int32                                         ActiveWidgetIndex;                                 // 0x0120(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_124[0x4];                                      // 0x0124(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnCurrentPageIndexChanged;                         // 0x0128(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_138[0x28];                                     // 0x0138(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void BeginAutoScrolling(float ScrollInterval);
	void EndAutoScrolling();
	void NextPage();
	void PreviousPage();
	void SetActiveWidget(class UWidget* Widget);
	void SetActiveWidgetIndex(int32 Param_Index);

	int32 GetActiveWidgetIndex() const;
	class UWidget* GetWidgetAtIndex(int32 Param_Index) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonWidgetCarousel">();
	}
	static class UCommonWidgetCarousel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonWidgetCarousel>();
	}
};
static_assert(alignof(UCommonWidgetCarousel) == 0x000008, "Wrong alignment on UCommonWidgetCarousel");
static_assert(sizeof(UCommonWidgetCarousel) == 0x000160, "Wrong size on UCommonWidgetCarousel");
static_assert(offsetof(UCommonWidgetCarousel, ActiveWidgetIndex) == 0x000120, "Member 'UCommonWidgetCarousel::ActiveWidgetIndex' has a wrong offset!");
static_assert(offsetof(UCommonWidgetCarousel, OnCurrentPageIndexChanged) == 0x000128, "Member 'UCommonWidgetCarousel::OnCurrentPageIndexChanged' has a wrong offset!");

// Class CommonUI.CommonWidgetCarouselNavBar
// 0x0048 (0x0150 - 0x0108)
class UCommonWidgetCarouselNavBar final : public UWidget
{
public:
	TSubclassOf<class UCommonButton>              ButtonWidgetType;                                  // 0x0108(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMargin                                ButtonPadding;                                     // 0x0110(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_120[0x10];                                     // 0x0120(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class UCommonWidgetCarousel*                  LinkedCarousel;                                    // 0x0130(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCommonButtonGroup*                     ButtonGroup;                                       // 0x0138(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<class UCommonButton*>                  Buttons;                                           // 0x0140(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)

public:
	void HandleButtonClicked(class UCommonButton* AssociatedButton, int32 ButtonIndex);
	void HandlePageChanged(class UCommonWidgetCarousel* CommonCarousel, int32 PageIndex);
	void SetLinkedCarousel(class UCommonWidgetCarousel* CommonCarousel);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonWidgetCarouselNavBar">();
	}
	static class UCommonWidgetCarouselNavBar* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonWidgetCarouselNavBar>();
	}
};
static_assert(alignof(UCommonWidgetCarouselNavBar) == 0x000008, "Wrong alignment on UCommonWidgetCarouselNavBar");
static_assert(sizeof(UCommonWidgetCarouselNavBar) == 0x000150, "Wrong size on UCommonWidgetCarouselNavBar");
static_assert(offsetof(UCommonWidgetCarouselNavBar, ButtonWidgetType) == 0x000108, "Member 'UCommonWidgetCarouselNavBar::ButtonWidgetType' has a wrong offset!");
static_assert(offsetof(UCommonWidgetCarouselNavBar, ButtonPadding) == 0x000110, "Member 'UCommonWidgetCarouselNavBar::ButtonPadding' has a wrong offset!");
static_assert(offsetof(UCommonWidgetCarouselNavBar, LinkedCarousel) == 0x000130, "Member 'UCommonWidgetCarouselNavBar::LinkedCarousel' has a wrong offset!");
static_assert(offsetof(UCommonWidgetCarouselNavBar, ButtonGroup) == 0x000138, "Member 'UCommonWidgetCarouselNavBar::ButtonGroup' has a wrong offset!");
static_assert(offsetof(UCommonWidgetCarouselNavBar, Buttons) == 0x000140, "Member 'UCommonWidgetCarouselNavBar::Buttons' has a wrong offset!");

// Class CommonUI.CommonWidgetSwitcher
// 0x0050 (0x0188 - 0x0138)
class UCommonWidgetSwitcher : public UWidgetSwitcher
{
public:
	UMulticastDelegateProperty_                   OnActiveWidgetDeactivated;                         // 0x0138(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnActiveWidgetChanged;                             // 0x0148(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	ECommonSwitcherTransition                     TransitionType;                                    // 0x0158(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ETransitionCurve                              TransitionCurveType;                               // 0x0159(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_15A[0x2];                                      // 0x015A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TransitionDuration;                                // 0x015C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_160[0x22];                                     // 0x0160(0x0022)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bWidgetActivationEnabled;                          // 0x0182(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bOutroPanelBelow;                                  // 0x0183(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_184[0x4];                                      // 0x0184(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ActivateNextWidget(bool bCanWrap);
	void ActivatePreviousWidget(bool bCanWrap);
	void ActivateWidget();
	void DeactivateWidget();
	void HandleActiveWidgetDeactivated(class UCommonActivatablePanel* DeactivatedPanel);
	void SetActiveWidget_Advanced(class UWidget* Widget, const bool AttemptActivationChange);
	void SetActiveWidgetIndex_Advanced(const int32 Param_Index, const bool AttemptActivationChange);
	void SetDisableTransitionAnimation(bool bDisableAnimation);

	bool HasWidgets() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CommonWidgetSwitcher">();
	}
	static class UCommonWidgetSwitcher* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommonWidgetSwitcher>();
	}
};
static_assert(alignof(UCommonWidgetSwitcher) == 0x000008, "Wrong alignment on UCommonWidgetSwitcher");
static_assert(sizeof(UCommonWidgetSwitcher) == 0x000188, "Wrong size on UCommonWidgetSwitcher");
static_assert(offsetof(UCommonWidgetSwitcher, OnActiveWidgetDeactivated) == 0x000138, "Member 'UCommonWidgetSwitcher::OnActiveWidgetDeactivated' has a wrong offset!");
static_assert(offsetof(UCommonWidgetSwitcher, OnActiveWidgetChanged) == 0x000148, "Member 'UCommonWidgetSwitcher::OnActiveWidgetChanged' has a wrong offset!");
static_assert(offsetof(UCommonWidgetSwitcher, TransitionType) == 0x000158, "Member 'UCommonWidgetSwitcher::TransitionType' has a wrong offset!");
static_assert(offsetof(UCommonWidgetSwitcher, TransitionCurveType) == 0x000159, "Member 'UCommonWidgetSwitcher::TransitionCurveType' has a wrong offset!");
static_assert(offsetof(UCommonWidgetSwitcher, TransitionDuration) == 0x00015C, "Member 'UCommonWidgetSwitcher::TransitionDuration' has a wrong offset!");
static_assert(offsetof(UCommonWidgetSwitcher, bWidgetActivationEnabled) == 0x000182, "Member 'UCommonWidgetSwitcher::bWidgetActivationEnabled' has a wrong offset!");
static_assert(offsetof(UCommonWidgetSwitcher, bOutroPanelBelow) == 0x000183, "Member 'UCommonWidgetSwitcher::bOutroPanelBelow' has a wrong offset!");

// Class CommonUI.CommonWidgetStack
// 0x0000 (0x0188 - 0x0188)
class UCommonWidgetStack final : public UCommonWidgetSwitcher
{
public:
	class UWidget* PopWidget();
	void PushWidget(class UWidget* InWidget);

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

}

