#pragma once

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

// Package: UMG

#include "Basic.hpp"

#include "Slate_structs.hpp"
#include "SlateCore_structs.hpp"
#include "UMG_structs.hpp"
#include "CoreUObject_structs.hpp"
#include "Engine_structs.hpp"
#include "InputCore_structs.hpp"


namespace SDK::Params
{

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

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

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

// Function UMG.Widget.SetClipping
// 0x0001 (0x0001 - 0x0000)
struct Widget_SetClipping final
{
public:
	EWidgetClipping                               InClipping;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_SetClipping) == 0x000001, "Wrong alignment on Widget_SetClipping");
static_assert(sizeof(Widget_SetClipping) == 0x000001, "Wrong size on Widget_SetClipping");
static_assert(offsetof(Widget_SetClipping, InClipping) == 0x000000, "Member 'Widget_SetClipping::InClipping' has a wrong offset!");

// Function UMG.Widget.SetCursor
// 0x0001 (0x0001 - 0x0000)
struct Widget_SetCursor final
{
public:
	EMouseCursor                                  InCursor;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_SetCursor) == 0x000001, "Wrong alignment on Widget_SetCursor");
static_assert(sizeof(Widget_SetCursor) == 0x000001, "Wrong size on Widget_SetCursor");
static_assert(offsetof(Widget_SetCursor, InCursor) == 0x000000, "Member 'Widget_SetCursor::InCursor' has a wrong offset!");

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

// Function UMG.Widget.SetNavigationRule
// 0x000C (0x000C - 0x0000)
struct Widget_SetNavigationRule final
{
public:
	EUINavigation                                 Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EUINavigationRule                             Rule;                                              // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2[0x2];                                        // 0x0002(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   WidgetToFocus;                                     // 0x0004(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_SetNavigationRule) == 0x000004, "Wrong alignment on Widget_SetNavigationRule");
static_assert(sizeof(Widget_SetNavigationRule) == 0x00000C, "Wrong size on Widget_SetNavigationRule");
static_assert(offsetof(Widget_SetNavigationRule, Direction) == 0x000000, "Member 'Widget_SetNavigationRule::Direction' has a wrong offset!");
static_assert(offsetof(Widget_SetNavigationRule, Rule) == 0x000001, "Member 'Widget_SetNavigationRule::Rule' has a wrong offset!");
static_assert(offsetof(Widget_SetNavigationRule, WidgetToFocus) == 0x000004, "Member 'Widget_SetNavigationRule::WidgetToFocus' has a wrong offset!");

// Function UMG.Widget.SetNavigationRuleBase
// 0x0002 (0x0002 - 0x0000)
struct Widget_SetNavigationRuleBase final
{
public:
	EUINavigation                                 Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EUINavigationRule                             Rule;                                              // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_SetNavigationRuleBase) == 0x000001, "Wrong alignment on Widget_SetNavigationRuleBase");
static_assert(sizeof(Widget_SetNavigationRuleBase) == 0x000002, "Wrong size on Widget_SetNavigationRuleBase");
static_assert(offsetof(Widget_SetNavigationRuleBase, Direction) == 0x000000, "Member 'Widget_SetNavigationRuleBase::Direction' has a wrong offset!");
static_assert(offsetof(Widget_SetNavigationRuleBase, Rule) == 0x000001, "Member 'Widget_SetNavigationRuleBase::Rule' has a wrong offset!");

// Function UMG.Widget.SetNavigationRuleCustom
// 0x0014 (0x0014 - 0x0000)
struct Widget_SetNavigationRuleCustom final
{
public:
	EUINavigation                                 Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(EUINavigation Navigation)>     InCustomDelegate;                                  // 0x0004(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_SetNavigationRuleCustom) == 0x000004, "Wrong alignment on Widget_SetNavigationRuleCustom");
static_assert(sizeof(Widget_SetNavigationRuleCustom) == 0x000014, "Wrong size on Widget_SetNavigationRuleCustom");
static_assert(offsetof(Widget_SetNavigationRuleCustom, Direction) == 0x000000, "Member 'Widget_SetNavigationRuleCustom::Direction' has a wrong offset!");
static_assert(offsetof(Widget_SetNavigationRuleCustom, InCustomDelegate) == 0x000004, "Member 'Widget_SetNavigationRuleCustom::InCustomDelegate' has a wrong offset!");

// Function UMG.Widget.SetNavigationRuleCustomBoundary
// 0x0014 (0x0014 - 0x0000)
struct Widget_SetNavigationRuleCustomBoundary final
{
public:
	EUINavigation                                 Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(EUINavigation Navigation)>     InCustomDelegate;                                  // 0x0004(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_SetNavigationRuleCustomBoundary) == 0x000004, "Wrong alignment on Widget_SetNavigationRuleCustomBoundary");
static_assert(sizeof(Widget_SetNavigationRuleCustomBoundary) == 0x000014, "Wrong size on Widget_SetNavigationRuleCustomBoundary");
static_assert(offsetof(Widget_SetNavigationRuleCustomBoundary, Direction) == 0x000000, "Member 'Widget_SetNavigationRuleCustomBoundary::Direction' has a wrong offset!");
static_assert(offsetof(Widget_SetNavigationRuleCustomBoundary, InCustomDelegate) == 0x000004, "Member 'Widget_SetNavigationRuleCustomBoundary::InCustomDelegate' has a wrong offset!");

// Function UMG.Widget.SetNavigationRuleExplicit
// 0x0010 (0x0010 - 0x0000)
struct Widget_SetNavigationRuleExplicit final
{
public:
	EUINavigation                                 Direction;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x7];                                        // 0x0001(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UWidget*                                InWidget;                                          // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_SetNavigationRuleExplicit) == 0x000008, "Wrong alignment on Widget_SetNavigationRuleExplicit");
static_assert(sizeof(Widget_SetNavigationRuleExplicit) == 0x000010, "Wrong size on Widget_SetNavigationRuleExplicit");
static_assert(offsetof(Widget_SetNavigationRuleExplicit, Direction) == 0x000000, "Member 'Widget_SetNavigationRuleExplicit::Direction' has a wrong offset!");
static_assert(offsetof(Widget_SetNavigationRuleExplicit, InWidget) == 0x000008, "Member 'Widget_SetNavigationRuleExplicit::InWidget' has a wrong offset!");

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

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

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

// Function UMG.Widget.SetRenderTransform
// 0x001C (0x001C - 0x0000)
struct Widget_SetRenderTransform final
{
public:
	struct FWidgetTransform                       InTransform;                                       // 0x0000(0x001C)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_SetRenderTransform) == 0x000004, "Wrong alignment on Widget_SetRenderTransform");
static_assert(sizeof(Widget_SetRenderTransform) == 0x00001C, "Wrong size on Widget_SetRenderTransform");
static_assert(offsetof(Widget_SetRenderTransform, InTransform) == 0x000000, "Member 'Widget_SetRenderTransform::InTransform' has a wrong offset!");

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

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

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

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

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

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

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

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

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

// Function UMG.Widget.GetCachedGeometry
// 0x0038 (0x0038 - 0x0000)
struct Widget_GetCachedGeometry final
{
public:
	struct FGeometry                              ReturnValue;                                       // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_GetCachedGeometry) == 0x000004, "Wrong alignment on Widget_GetCachedGeometry");
static_assert(sizeof(Widget_GetCachedGeometry) == 0x000038, "Wrong size on Widget_GetCachedGeometry");
static_assert(offsetof(Widget_GetCachedGeometry, ReturnValue) == 0x000000, "Member 'Widget_GetCachedGeometry::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

// Function UMG.Widget.GetPaintSpaceGeometry
// 0x0038 (0x0038 - 0x0000)
struct Widget_GetPaintSpaceGeometry final
{
public:
	struct FGeometry                              ReturnValue;                                       // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_GetPaintSpaceGeometry) == 0x000004, "Wrong alignment on Widget_GetPaintSpaceGeometry");
static_assert(sizeof(Widget_GetPaintSpaceGeometry) == 0x000038, "Wrong size on Widget_GetPaintSpaceGeometry");
static_assert(offsetof(Widget_GetPaintSpaceGeometry, ReturnValue) == 0x000000, "Member 'Widget_GetPaintSpaceGeometry::ReturnValue' has a wrong offset!");

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

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

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

// Function UMG.Widget.GetTickSpaceGeometry
// 0x0038 (0x0038 - 0x0000)
struct Widget_GetTickSpaceGeometry final
{
public:
	struct FGeometry                              ReturnValue;                                       // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Widget_GetTickSpaceGeometry) == 0x000004, "Wrong alignment on Widget_GetTickSpaceGeometry");
static_assert(sizeof(Widget_GetTickSpaceGeometry) == 0x000038, "Wrong size on Widget_GetTickSpaceGeometry");
static_assert(offsetof(Widget_GetTickSpaceGeometry, ReturnValue) == 0x000000, "Member 'Widget_GetTickSpaceGeometry::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.PanelWidget.GetChildIndex
// 0x0010 (0x0010 - 0x0000)
struct PanelWidget_GetChildIndex final
{
public:
	const class UWidget*                          Content;                                           // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(PanelWidget_GetChildIndex) == 0x000008, "Wrong alignment on PanelWidget_GetChildIndex");
static_assert(sizeof(PanelWidget_GetChildIndex) == 0x000010, "Wrong size on PanelWidget_GetChildIndex");
static_assert(offsetof(PanelWidget_GetChildIndex, Content) == 0x000000, "Member 'PanelWidget_GetChildIndex::Content' has a wrong offset!");
static_assert(offsetof(PanelWidget_GetChildIndex, ReturnValue) == 0x000008, "Member 'PanelWidget_GetChildIndex::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

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

// Function UMG.Border.SetBrush
// 0x0088 (0x0088 - 0x0000)
struct Border_SetBrush final
{
public:
	struct FSlateBrush                            InBrush;                                           // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(Border_SetBrush) == 0x000008, "Wrong alignment on Border_SetBrush");
static_assert(sizeof(Border_SetBrush) == 0x000088, "Wrong size on Border_SetBrush");
static_assert(offsetof(Border_SetBrush, InBrush) == 0x000000, "Member 'Border_SetBrush::InBrush' has a wrong offset!");

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

// Function UMG.Border.SetBrushFromAsset
// 0x0008 (0x0008 - 0x0000)
struct Border_SetBrushFromAsset final
{
public:
	class USlateBrushAsset*                       Asset;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Border_SetBrushFromAsset) == 0x000008, "Wrong alignment on Border_SetBrushFromAsset");
static_assert(sizeof(Border_SetBrushFromAsset) == 0x000008, "Wrong size on Border_SetBrushFromAsset");
static_assert(offsetof(Border_SetBrushFromAsset, Asset) == 0x000000, "Member 'Border_SetBrushFromAsset::Asset' has a wrong offset!");

// Function UMG.Border.SetBrushFromMaterial
// 0x0008 (0x0008 - 0x0000)
struct Border_SetBrushFromMaterial final
{
public:
	class UMaterialInterface*                     Material;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Border_SetBrushFromMaterial) == 0x000008, "Wrong alignment on Border_SetBrushFromMaterial");
static_assert(sizeof(Border_SetBrushFromMaterial) == 0x000008, "Wrong size on Border_SetBrushFromMaterial");
static_assert(offsetof(Border_SetBrushFromMaterial, Material) == 0x000000, "Member 'Border_SetBrushFromMaterial::Material' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.UserWidget.AddToViewport
// 0x0004 (0x0004 - 0x0000)
struct UserWidget_AddToViewport final
{
public:
	int32                                         ZOrder;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_AddToViewport) == 0x000004, "Wrong alignment on UserWidget_AddToViewport");
static_assert(sizeof(UserWidget_AddToViewport) == 0x000004, "Wrong size on UserWidget_AddToViewport");
static_assert(offsetof(UserWidget_AddToViewport, ZOrder) == 0x000000, "Member 'UserWidget_AddToViewport::ZOrder' has a wrong offset!");

// Function UMG.UserWidget.BindToAnimationEvent
// 0x0028 (0x0028 - 0x0000)
struct UserWidget_BindToAnimationEvent final
{
public:
	class UWidgetAnimation*                       Animation;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             Delegate;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
	EWidgetAnimationEvent                         AnimationEvent;                                    // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x3];                                       // 0x0019(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   userTag;                                           // 0x001C(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24[0x4];                                       // 0x0024(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(UserWidget_BindToAnimationEvent) == 0x000008, "Wrong alignment on UserWidget_BindToAnimationEvent");
static_assert(sizeof(UserWidget_BindToAnimationEvent) == 0x000028, "Wrong size on UserWidget_BindToAnimationEvent");
static_assert(offsetof(UserWidget_BindToAnimationEvent, Animation) == 0x000000, "Member 'UserWidget_BindToAnimationEvent::Animation' has a wrong offset!");
static_assert(offsetof(UserWidget_BindToAnimationEvent, Delegate) == 0x000008, "Member 'UserWidget_BindToAnimationEvent::Delegate' has a wrong offset!");
static_assert(offsetof(UserWidget_BindToAnimationEvent, AnimationEvent) == 0x000018, "Member 'UserWidget_BindToAnimationEvent::AnimationEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_BindToAnimationEvent, userTag) == 0x00001C, "Member 'UserWidget_BindToAnimationEvent::userTag' has a wrong offset!");

// Function UMG.UserWidget.BindToAnimationFinished
// 0x0018 (0x0018 - 0x0000)
struct UserWidget_BindToAnimationFinished final
{
public:
	class UWidgetAnimation*                       Animation;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             Delegate;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_BindToAnimationFinished) == 0x000008, "Wrong alignment on UserWidget_BindToAnimationFinished");
static_assert(sizeof(UserWidget_BindToAnimationFinished) == 0x000018, "Wrong size on UserWidget_BindToAnimationFinished");
static_assert(offsetof(UserWidget_BindToAnimationFinished, Animation) == 0x000000, "Member 'UserWidget_BindToAnimationFinished::Animation' has a wrong offset!");
static_assert(offsetof(UserWidget_BindToAnimationFinished, Delegate) == 0x000008, "Member 'UserWidget_BindToAnimationFinished::Delegate' has a wrong offset!");

// Function UMG.UserWidget.BindToAnimationStarted
// 0x0018 (0x0018 - 0x0000)
struct UserWidget_BindToAnimationStarted final
{
public:
	class UWidgetAnimation*                       Animation;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             Delegate;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_BindToAnimationStarted) == 0x000008, "Wrong alignment on UserWidget_BindToAnimationStarted");
static_assert(sizeof(UserWidget_BindToAnimationStarted) == 0x000018, "Wrong size on UserWidget_BindToAnimationStarted");
static_assert(offsetof(UserWidget_BindToAnimationStarted, Animation) == 0x000000, "Member 'UserWidget_BindToAnimationStarted::Animation' has a wrong offset!");
static_assert(offsetof(UserWidget_BindToAnimationStarted, Delegate) == 0x000008, "Member 'UserWidget_BindToAnimationStarted::Delegate' has a wrong offset!");

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

// Function UMG.UserWidget.ListenForInputAction
// 0x001C (0x001C - 0x0000)
struct UserWidget_ListenForInputAction final
{
public:
	class FName                                   ActionName;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInputEvent                                   EventType;                                         // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bConsume;                                          // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x2];                                        // 0x000A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void()>                             Callback;                                          // 0x000C(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_ListenForInputAction) == 0x000004, "Wrong alignment on UserWidget_ListenForInputAction");
static_assert(sizeof(UserWidget_ListenForInputAction) == 0x00001C, "Wrong size on UserWidget_ListenForInputAction");
static_assert(offsetof(UserWidget_ListenForInputAction, ActionName) == 0x000000, "Member 'UserWidget_ListenForInputAction::ActionName' has a wrong offset!");
static_assert(offsetof(UserWidget_ListenForInputAction, EventType) == 0x000008, "Member 'UserWidget_ListenForInputAction::EventType' has a wrong offset!");
static_assert(offsetof(UserWidget_ListenForInputAction, bConsume) == 0x000009, "Member 'UserWidget_ListenForInputAction::bConsume' has a wrong offset!");
static_assert(offsetof(UserWidget_ListenForInputAction, Callback) == 0x00000C, "Member 'UserWidget_ListenForInputAction::Callback' has a wrong offset!");

// Function UMG.UserWidget.OnAddedToFocusPath
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_OnAddedToFocusPath final
{
public:
	struct FFocusEvent                            InFocusEvent;                                      // 0x0000(0x0008)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnAddedToFocusPath) == 0x000004, "Wrong alignment on UserWidget_OnAddedToFocusPath");
static_assert(sizeof(UserWidget_OnAddedToFocusPath) == 0x000008, "Wrong size on UserWidget_OnAddedToFocusPath");
static_assert(offsetof(UserWidget_OnAddedToFocusPath, InFocusEvent) == 0x000000, "Member 'UserWidget_OnAddedToFocusPath::InFocusEvent' has a wrong offset!");

// Function UMG.UserWidget.OnAnalogValueChanged
// 0x0130 (0x0130 - 0x0000)
struct UserWidget_OnAnalogValueChanged final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FAnalogInputEvent                      InAnalogInputEvent;                                // 0x0038(0x0040)(Parm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x0078(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnAnalogValueChanged) == 0x000008, "Wrong alignment on UserWidget_OnAnalogValueChanged");
static_assert(sizeof(UserWidget_OnAnalogValueChanged) == 0x000130, "Wrong size on UserWidget_OnAnalogValueChanged");
static_assert(offsetof(UserWidget_OnAnalogValueChanged, MyGeometry) == 0x000000, "Member 'UserWidget_OnAnalogValueChanged::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnAnalogValueChanged, InAnalogInputEvent) == 0x000038, "Member 'UserWidget_OnAnalogValueChanged::InAnalogInputEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnAnalogValueChanged, ReturnValue) == 0x000078, "Member 'UserWidget_OnAnalogValueChanged::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnAnimationFinished
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_OnAnimationFinished final
{
public:
	const class UWidgetAnimation*                 Animation;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnAnimationFinished) == 0x000008, "Wrong alignment on UserWidget_OnAnimationFinished");
static_assert(sizeof(UserWidget_OnAnimationFinished) == 0x000008, "Wrong size on UserWidget_OnAnimationFinished");
static_assert(offsetof(UserWidget_OnAnimationFinished, Animation) == 0x000000, "Member 'UserWidget_OnAnimationFinished::Animation' has a wrong offset!");

// Function UMG.UserWidget.OnAnimationStarted
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_OnAnimationStarted final
{
public:
	const class UWidgetAnimation*                 Animation;                                         // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnAnimationStarted) == 0x000008, "Wrong alignment on UserWidget_OnAnimationStarted");
static_assert(sizeof(UserWidget_OnAnimationStarted) == 0x000008, "Wrong size on UserWidget_OnAnimationStarted");
static_assert(offsetof(UserWidget_OnAnimationStarted, Animation) == 0x000000, "Member 'UserWidget_OnAnimationStarted::Animation' has a wrong offset!");

// Function UMG.UserWidget.OnDragCancelled
// 0x0078 (0x0078 - 0x0000)
struct UserWidget_OnDragCancelled final
{
public:
	struct FPointerEvent                          PointerEvent;                                      // 0x0000(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UDragDropOperation*                     Operation;                                         // 0x0070(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnDragCancelled) == 0x000008, "Wrong alignment on UserWidget_OnDragCancelled");
static_assert(sizeof(UserWidget_OnDragCancelled) == 0x000078, "Wrong size on UserWidget_OnDragCancelled");
static_assert(offsetof(UserWidget_OnDragCancelled, PointerEvent) == 0x000000, "Member 'UserWidget_OnDragCancelled::PointerEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDragCancelled, Operation) == 0x000070, "Member 'UserWidget_OnDragCancelled::Operation' has a wrong offset!");

// Function UMG.UserWidget.OnDragDetected
// 0x00B0 (0x00B0 - 0x0000)
struct UserWidget_OnDragDetected final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          PointerEvent;                                      // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UDragDropOperation*                     Operation;                                         // 0x00A8(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnDragDetected) == 0x000008, "Wrong alignment on UserWidget_OnDragDetected");
static_assert(sizeof(UserWidget_OnDragDetected) == 0x0000B0, "Wrong size on UserWidget_OnDragDetected");
static_assert(offsetof(UserWidget_OnDragDetected, MyGeometry) == 0x000000, "Member 'UserWidget_OnDragDetected::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDragDetected, PointerEvent) == 0x000038, "Member 'UserWidget_OnDragDetected::PointerEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDragDetected, Operation) == 0x0000A8, "Member 'UserWidget_OnDragDetected::Operation' has a wrong offset!");

// Function UMG.UserWidget.OnDragEnter
// 0x00B0 (0x00B0 - 0x0000)
struct UserWidget_OnDragEnter final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          PointerEvent;                                      // 0x0038(0x0070)(Parm, NativeAccessSpecifierPublic)
	class UDragDropOperation*                     Operation;                                         // 0x00A8(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnDragEnter) == 0x000008, "Wrong alignment on UserWidget_OnDragEnter");
static_assert(sizeof(UserWidget_OnDragEnter) == 0x0000B0, "Wrong size on UserWidget_OnDragEnter");
static_assert(offsetof(UserWidget_OnDragEnter, MyGeometry) == 0x000000, "Member 'UserWidget_OnDragEnter::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDragEnter, PointerEvent) == 0x000038, "Member 'UserWidget_OnDragEnter::PointerEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDragEnter, Operation) == 0x0000A8, "Member 'UserWidget_OnDragEnter::Operation' has a wrong offset!");

// Function UMG.UserWidget.OnDragLeave
// 0x0078 (0x0078 - 0x0000)
struct UserWidget_OnDragLeave final
{
public:
	struct FPointerEvent                          PointerEvent;                                      // 0x0000(0x0070)(Parm, NativeAccessSpecifierPublic)
	class UDragDropOperation*                     Operation;                                         // 0x0070(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnDragLeave) == 0x000008, "Wrong alignment on UserWidget_OnDragLeave");
static_assert(sizeof(UserWidget_OnDragLeave) == 0x000078, "Wrong size on UserWidget_OnDragLeave");
static_assert(offsetof(UserWidget_OnDragLeave, PointerEvent) == 0x000000, "Member 'UserWidget_OnDragLeave::PointerEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDragLeave, Operation) == 0x000070, "Member 'UserWidget_OnDragLeave::Operation' has a wrong offset!");

// Function UMG.UserWidget.OnDragOver
// 0x00B8 (0x00B8 - 0x0000)
struct UserWidget_OnDragOver final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          PointerEvent;                                      // 0x0038(0x0070)(Parm, NativeAccessSpecifierPublic)
	class UDragDropOperation*                     Operation;                                         // 0x00A8(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00B0(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(UserWidget_OnDragOver) == 0x000008, "Wrong alignment on UserWidget_OnDragOver");
static_assert(sizeof(UserWidget_OnDragOver) == 0x0000B8, "Wrong size on UserWidget_OnDragOver");
static_assert(offsetof(UserWidget_OnDragOver, MyGeometry) == 0x000000, "Member 'UserWidget_OnDragOver::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDragOver, PointerEvent) == 0x000038, "Member 'UserWidget_OnDragOver::PointerEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDragOver, Operation) == 0x0000A8, "Member 'UserWidget_OnDragOver::Operation' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDragOver, ReturnValue) == 0x0000B0, "Member 'UserWidget_OnDragOver::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnDrop
// 0x00B8 (0x00B8 - 0x0000)
struct UserWidget_OnDrop final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          PointerEvent;                                      // 0x0038(0x0070)(Parm, NativeAccessSpecifierPublic)
	class UDragDropOperation*                     Operation;                                         // 0x00A8(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x00B0(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(UserWidget_OnDrop) == 0x000008, "Wrong alignment on UserWidget_OnDrop");
static_assert(sizeof(UserWidget_OnDrop) == 0x0000B8, "Wrong size on UserWidget_OnDrop");
static_assert(offsetof(UserWidget_OnDrop, MyGeometry) == 0x000000, "Member 'UserWidget_OnDrop::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDrop, PointerEvent) == 0x000038, "Member 'UserWidget_OnDrop::PointerEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDrop, Operation) == 0x0000A8, "Member 'UserWidget_OnDrop::Operation' has a wrong offset!");
static_assert(offsetof(UserWidget_OnDrop, ReturnValue) == 0x0000B0, "Member 'UserWidget_OnDrop::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnFocusLost
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_OnFocusLost final
{
public:
	struct FFocusEvent                            InFocusEvent;                                      // 0x0000(0x0008)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnFocusLost) == 0x000004, "Wrong alignment on UserWidget_OnFocusLost");
static_assert(sizeof(UserWidget_OnFocusLost) == 0x000008, "Wrong size on UserWidget_OnFocusLost");
static_assert(offsetof(UserWidget_OnFocusLost, InFocusEvent) == 0x000000, "Member 'UserWidget_OnFocusLost::InFocusEvent' has a wrong offset!");

// Function UMG.UserWidget.OnFocusReceived
// 0x00F8 (0x00F8 - 0x0000)
struct UserWidget_OnFocusReceived final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FFocusEvent                            InFocusEvent;                                      // 0x0038(0x0008)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x0040(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnFocusReceived) == 0x000008, "Wrong alignment on UserWidget_OnFocusReceived");
static_assert(sizeof(UserWidget_OnFocusReceived) == 0x0000F8, "Wrong size on UserWidget_OnFocusReceived");
static_assert(offsetof(UserWidget_OnFocusReceived, MyGeometry) == 0x000000, "Member 'UserWidget_OnFocusReceived::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnFocusReceived, InFocusEvent) == 0x000038, "Member 'UserWidget_OnFocusReceived::InFocusEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnFocusReceived, ReturnValue) == 0x000040, "Member 'UserWidget_OnFocusReceived::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnKeyChar
// 0x0110 (0x0110 - 0x0000)
struct UserWidget_OnKeyChar final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FCharacterEvent                        InCharacterEvent;                                  // 0x0038(0x0020)(Parm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x0058(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnKeyChar) == 0x000008, "Wrong alignment on UserWidget_OnKeyChar");
static_assert(sizeof(UserWidget_OnKeyChar) == 0x000110, "Wrong size on UserWidget_OnKeyChar");
static_assert(offsetof(UserWidget_OnKeyChar, MyGeometry) == 0x000000, "Member 'UserWidget_OnKeyChar::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnKeyChar, InCharacterEvent) == 0x000038, "Member 'UserWidget_OnKeyChar::InCharacterEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnKeyChar, ReturnValue) == 0x000058, "Member 'UserWidget_OnKeyChar::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnKeyDown
// 0x0128 (0x0128 - 0x0000)
struct UserWidget_OnKeyDown final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FKeyEvent                              InKeyEvent;                                        // 0x0038(0x0038)(Parm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x0070(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnKeyDown) == 0x000008, "Wrong alignment on UserWidget_OnKeyDown");
static_assert(sizeof(UserWidget_OnKeyDown) == 0x000128, "Wrong size on UserWidget_OnKeyDown");
static_assert(offsetof(UserWidget_OnKeyDown, MyGeometry) == 0x000000, "Member 'UserWidget_OnKeyDown::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnKeyDown, InKeyEvent) == 0x000038, "Member 'UserWidget_OnKeyDown::InKeyEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnKeyDown, ReturnValue) == 0x000070, "Member 'UserWidget_OnKeyDown::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnKeyUp
// 0x0128 (0x0128 - 0x0000)
struct UserWidget_OnKeyUp final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FKeyEvent                              InKeyEvent;                                        // 0x0038(0x0038)(Parm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x0070(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnKeyUp) == 0x000008, "Wrong alignment on UserWidget_OnKeyUp");
static_assert(sizeof(UserWidget_OnKeyUp) == 0x000128, "Wrong size on UserWidget_OnKeyUp");
static_assert(offsetof(UserWidget_OnKeyUp, MyGeometry) == 0x000000, "Member 'UserWidget_OnKeyUp::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnKeyUp, InKeyEvent) == 0x000038, "Member 'UserWidget_OnKeyUp::InKeyEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnKeyUp, ReturnValue) == 0x000070, "Member 'UserWidget_OnKeyUp::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnMotionDetected
// 0x0138 (0x0138 - 0x0000)
struct UserWidget_OnMotionDetected final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FMotionEvent                           InMotionEvent;                                     // 0x0038(0x0048)(Parm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x0080(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnMotionDetected) == 0x000008, "Wrong alignment on UserWidget_OnMotionDetected");
static_assert(sizeof(UserWidget_OnMotionDetected) == 0x000138, "Wrong size on UserWidget_OnMotionDetected");
static_assert(offsetof(UserWidget_OnMotionDetected, MyGeometry) == 0x000000, "Member 'UserWidget_OnMotionDetected::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMotionDetected, InMotionEvent) == 0x000038, "Member 'UserWidget_OnMotionDetected::InMotionEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMotionDetected, ReturnValue) == 0x000080, "Member 'UserWidget_OnMotionDetected::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnMouseButtonDoubleClick
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnMouseButtonDoubleClick final
{
public:
	struct FGeometry                              InMyGeometry;                                      // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          InMouseEvent;                                      // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnMouseButtonDoubleClick) == 0x000008, "Wrong alignment on UserWidget_OnMouseButtonDoubleClick");
static_assert(sizeof(UserWidget_OnMouseButtonDoubleClick) == 0x000160, "Wrong size on UserWidget_OnMouseButtonDoubleClick");
static_assert(offsetof(UserWidget_OnMouseButtonDoubleClick, InMyGeometry) == 0x000000, "Member 'UserWidget_OnMouseButtonDoubleClick::InMyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseButtonDoubleClick, InMouseEvent) == 0x000038, "Member 'UserWidget_OnMouseButtonDoubleClick::InMouseEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseButtonDoubleClick, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnMouseButtonDoubleClick::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnMouseButtonDown
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnMouseButtonDown final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          MouseEvent;                                        // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnMouseButtonDown) == 0x000008, "Wrong alignment on UserWidget_OnMouseButtonDown");
static_assert(sizeof(UserWidget_OnMouseButtonDown) == 0x000160, "Wrong size on UserWidget_OnMouseButtonDown");
static_assert(offsetof(UserWidget_OnMouseButtonDown, MyGeometry) == 0x000000, "Member 'UserWidget_OnMouseButtonDown::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseButtonDown, MouseEvent) == 0x000038, "Member 'UserWidget_OnMouseButtonDown::MouseEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseButtonDown, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnMouseButtonDown::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnMouseButtonUp
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnMouseButtonUp final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          MouseEvent;                                        // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnMouseButtonUp) == 0x000008, "Wrong alignment on UserWidget_OnMouseButtonUp");
static_assert(sizeof(UserWidget_OnMouseButtonUp) == 0x000160, "Wrong size on UserWidget_OnMouseButtonUp");
static_assert(offsetof(UserWidget_OnMouseButtonUp, MyGeometry) == 0x000000, "Member 'UserWidget_OnMouseButtonUp::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseButtonUp, MouseEvent) == 0x000038, "Member 'UserWidget_OnMouseButtonUp::MouseEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseButtonUp, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnMouseButtonUp::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnMouseEnter
// 0x00A8 (0x00A8 - 0x0000)
struct UserWidget_OnMouseEnter final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          MouseEvent;                                        // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnMouseEnter) == 0x000008, "Wrong alignment on UserWidget_OnMouseEnter");
static_assert(sizeof(UserWidget_OnMouseEnter) == 0x0000A8, "Wrong size on UserWidget_OnMouseEnter");
static_assert(offsetof(UserWidget_OnMouseEnter, MyGeometry) == 0x000000, "Member 'UserWidget_OnMouseEnter::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseEnter, MouseEvent) == 0x000038, "Member 'UserWidget_OnMouseEnter::MouseEvent' has a wrong offset!");

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

// Function UMG.UserWidget.OnMouseMove
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnMouseMove final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          MouseEvent;                                        // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnMouseMove) == 0x000008, "Wrong alignment on UserWidget_OnMouseMove");
static_assert(sizeof(UserWidget_OnMouseMove) == 0x000160, "Wrong size on UserWidget_OnMouseMove");
static_assert(offsetof(UserWidget_OnMouseMove, MyGeometry) == 0x000000, "Member 'UserWidget_OnMouseMove::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseMove, MouseEvent) == 0x000038, "Member 'UserWidget_OnMouseMove::MouseEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseMove, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnMouseMove::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnMouseWheel
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnMouseWheel final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          MouseEvent;                                        // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnMouseWheel) == 0x000008, "Wrong alignment on UserWidget_OnMouseWheel");
static_assert(sizeof(UserWidget_OnMouseWheel) == 0x000160, "Wrong size on UserWidget_OnMouseWheel");
static_assert(offsetof(UserWidget_OnMouseWheel, MyGeometry) == 0x000000, "Member 'UserWidget_OnMouseWheel::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseWheel, MouseEvent) == 0x000038, "Member 'UserWidget_OnMouseWheel::MouseEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnMouseWheel, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnMouseWheel::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnPreviewKeyDown
// 0x0128 (0x0128 - 0x0000)
struct UserWidget_OnPreviewKeyDown final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FKeyEvent                              InKeyEvent;                                        // 0x0038(0x0038)(Parm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x0070(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnPreviewKeyDown) == 0x000008, "Wrong alignment on UserWidget_OnPreviewKeyDown");
static_assert(sizeof(UserWidget_OnPreviewKeyDown) == 0x000128, "Wrong size on UserWidget_OnPreviewKeyDown");
static_assert(offsetof(UserWidget_OnPreviewKeyDown, MyGeometry) == 0x000000, "Member 'UserWidget_OnPreviewKeyDown::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnPreviewKeyDown, InKeyEvent) == 0x000038, "Member 'UserWidget_OnPreviewKeyDown::InKeyEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnPreviewKeyDown, ReturnValue) == 0x000070, "Member 'UserWidget_OnPreviewKeyDown::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnPreviewMouseButtonDown
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnPreviewMouseButtonDown final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          MouseEvent;                                        // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnPreviewMouseButtonDown) == 0x000008, "Wrong alignment on UserWidget_OnPreviewMouseButtonDown");
static_assert(sizeof(UserWidget_OnPreviewMouseButtonDown) == 0x000160, "Wrong size on UserWidget_OnPreviewMouseButtonDown");
static_assert(offsetof(UserWidget_OnPreviewMouseButtonDown, MyGeometry) == 0x000000, "Member 'UserWidget_OnPreviewMouseButtonDown::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnPreviewMouseButtonDown, MouseEvent) == 0x000038, "Member 'UserWidget_OnPreviewMouseButtonDown::MouseEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnPreviewMouseButtonDown, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnPreviewMouseButtonDown::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnRemovedFromFocusPath
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_OnRemovedFromFocusPath final
{
public:
	struct FFocusEvent                            InFocusEvent;                                      // 0x0000(0x0008)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnRemovedFromFocusPath) == 0x000004, "Wrong alignment on UserWidget_OnRemovedFromFocusPath");
static_assert(sizeof(UserWidget_OnRemovedFromFocusPath) == 0x000008, "Wrong size on UserWidget_OnRemovedFromFocusPath");
static_assert(offsetof(UserWidget_OnRemovedFromFocusPath, InFocusEvent) == 0x000000, "Member 'UserWidget_OnRemovedFromFocusPath::InFocusEvent' has a wrong offset!");

// Function UMG.UserWidget.OnTouchEnded
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnTouchEnded final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          InTouchEvent;                                      // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnTouchEnded) == 0x000008, "Wrong alignment on UserWidget_OnTouchEnded");
static_assert(sizeof(UserWidget_OnTouchEnded) == 0x000160, "Wrong size on UserWidget_OnTouchEnded");
static_assert(offsetof(UserWidget_OnTouchEnded, MyGeometry) == 0x000000, "Member 'UserWidget_OnTouchEnded::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchEnded, InTouchEvent) == 0x000038, "Member 'UserWidget_OnTouchEnded::InTouchEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchEnded, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnTouchEnded::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnTouchForceChanged
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnTouchForceChanged final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          InTouchEvent;                                      // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnTouchForceChanged) == 0x000008, "Wrong alignment on UserWidget_OnTouchForceChanged");
static_assert(sizeof(UserWidget_OnTouchForceChanged) == 0x000160, "Wrong size on UserWidget_OnTouchForceChanged");
static_assert(offsetof(UserWidget_OnTouchForceChanged, MyGeometry) == 0x000000, "Member 'UserWidget_OnTouchForceChanged::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchForceChanged, InTouchEvent) == 0x000038, "Member 'UserWidget_OnTouchForceChanged::InTouchEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchForceChanged, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnTouchForceChanged::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnTouchGesture
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnTouchGesture final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          GestureEvent;                                      // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnTouchGesture) == 0x000008, "Wrong alignment on UserWidget_OnTouchGesture");
static_assert(sizeof(UserWidget_OnTouchGesture) == 0x000160, "Wrong size on UserWidget_OnTouchGesture");
static_assert(offsetof(UserWidget_OnTouchGesture, MyGeometry) == 0x000000, "Member 'UserWidget_OnTouchGesture::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchGesture, GestureEvent) == 0x000038, "Member 'UserWidget_OnTouchGesture::GestureEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchGesture, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnTouchGesture::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnTouchMoved
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnTouchMoved final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          InTouchEvent;                                      // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnTouchMoved) == 0x000008, "Wrong alignment on UserWidget_OnTouchMoved");
static_assert(sizeof(UserWidget_OnTouchMoved) == 0x000160, "Wrong size on UserWidget_OnTouchMoved");
static_assert(offsetof(UserWidget_OnTouchMoved, MyGeometry) == 0x000000, "Member 'UserWidget_OnTouchMoved::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchMoved, InTouchEvent) == 0x000038, "Member 'UserWidget_OnTouchMoved::InTouchEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchMoved, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnTouchMoved::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.OnTouchStarted
// 0x0160 (0x0160 - 0x0000)
struct UserWidget_OnTouchStarted final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FPointerEvent                          InTouchEvent;                                      // 0x0038(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00A8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnTouchStarted) == 0x000008, "Wrong alignment on UserWidget_OnTouchStarted");
static_assert(sizeof(UserWidget_OnTouchStarted) == 0x000160, "Wrong size on UserWidget_OnTouchStarted");
static_assert(offsetof(UserWidget_OnTouchStarted, MyGeometry) == 0x000000, "Member 'UserWidget_OnTouchStarted::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchStarted, InTouchEvent) == 0x000038, "Member 'UserWidget_OnTouchStarted::InTouchEvent' has a wrong offset!");
static_assert(offsetof(UserWidget_OnTouchStarted, ReturnValue) == 0x0000A8, "Member 'UserWidget_OnTouchStarted::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.PauseAnimation
// 0x0010 (0x0010 - 0x0000)
struct UserWidget_PauseAnimation final
{
public:
	const class UWidgetAnimation*                 InAnimation;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(UserWidget_PauseAnimation) == 0x000008, "Wrong alignment on UserWidget_PauseAnimation");
static_assert(sizeof(UserWidget_PauseAnimation) == 0x000010, "Wrong size on UserWidget_PauseAnimation");
static_assert(offsetof(UserWidget_PauseAnimation, InAnimation) == 0x000000, "Member 'UserWidget_PauseAnimation::InAnimation' has a wrong offset!");
static_assert(offsetof(UserWidget_PauseAnimation, ReturnValue) == 0x000008, "Member 'UserWidget_PauseAnimation::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.PlayAnimation
// 0x0028 (0x0028 - 0x0000)
struct UserWidget_PlayAnimation final
{
public:
	class UWidgetAnimation*                       InAnimation;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StartAtTime;                                       // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumLoopsToPlay;                                    // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EUMGSequencePlayMode                          PlayMode;                                          // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x3];                                       // 0x0011(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         PlaybackSpeed;                                     // 0x0014(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRestoreState;                                     // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UUMGSequencePlayer*                     ReturnValue;                                       // 0x0020(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_PlayAnimation) == 0x000008, "Wrong alignment on UserWidget_PlayAnimation");
static_assert(sizeof(UserWidget_PlayAnimation) == 0x000028, "Wrong size on UserWidget_PlayAnimation");
static_assert(offsetof(UserWidget_PlayAnimation, InAnimation) == 0x000000, "Member 'UserWidget_PlayAnimation::InAnimation' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimation, StartAtTime) == 0x000008, "Member 'UserWidget_PlayAnimation::StartAtTime' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimation, NumLoopsToPlay) == 0x00000C, "Member 'UserWidget_PlayAnimation::NumLoopsToPlay' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimation, PlayMode) == 0x000010, "Member 'UserWidget_PlayAnimation::PlayMode' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimation, PlaybackSpeed) == 0x000014, "Member 'UserWidget_PlayAnimation::PlaybackSpeed' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimation, bRestoreState) == 0x000018, "Member 'UserWidget_PlayAnimation::bRestoreState' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimation, ReturnValue) == 0x000020, "Member 'UserWidget_PlayAnimation::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.PlayAnimationForward
// 0x0018 (0x0018 - 0x0000)
struct UserWidget_PlayAnimationForward final
{
public:
	class UWidgetAnimation*                       InAnimation;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PlaybackSpeed;                                     // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRestoreState;                                     // 0x000C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UUMGSequencePlayer*                     ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_PlayAnimationForward) == 0x000008, "Wrong alignment on UserWidget_PlayAnimationForward");
static_assert(sizeof(UserWidget_PlayAnimationForward) == 0x000018, "Wrong size on UserWidget_PlayAnimationForward");
static_assert(offsetof(UserWidget_PlayAnimationForward, InAnimation) == 0x000000, "Member 'UserWidget_PlayAnimationForward::InAnimation' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationForward, PlaybackSpeed) == 0x000008, "Member 'UserWidget_PlayAnimationForward::PlaybackSpeed' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationForward, bRestoreState) == 0x00000C, "Member 'UserWidget_PlayAnimationForward::bRestoreState' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationForward, ReturnValue) == 0x000010, "Member 'UserWidget_PlayAnimationForward::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.PlayAnimationReverse
// 0x0018 (0x0018 - 0x0000)
struct UserWidget_PlayAnimationReverse final
{
public:
	class UWidgetAnimation*                       InAnimation;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PlaybackSpeed;                                     // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRestoreState;                                     // 0x000C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UUMGSequencePlayer*                     ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_PlayAnimationReverse) == 0x000008, "Wrong alignment on UserWidget_PlayAnimationReverse");
static_assert(sizeof(UserWidget_PlayAnimationReverse) == 0x000018, "Wrong size on UserWidget_PlayAnimationReverse");
static_assert(offsetof(UserWidget_PlayAnimationReverse, InAnimation) == 0x000000, "Member 'UserWidget_PlayAnimationReverse::InAnimation' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationReverse, PlaybackSpeed) == 0x000008, "Member 'UserWidget_PlayAnimationReverse::PlaybackSpeed' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationReverse, bRestoreState) == 0x00000C, "Member 'UserWidget_PlayAnimationReverse::bRestoreState' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationReverse, ReturnValue) == 0x000010, "Member 'UserWidget_PlayAnimationReverse::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.PlayAnimationTimeRange
// 0x0028 (0x0028 - 0x0000)
struct UserWidget_PlayAnimationTimeRange final
{
public:
	class UWidgetAnimation*                       InAnimation;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StartAtTime;                                       // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         EndAtTime;                                         // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumLoopsToPlay;                                    // 0x0010(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EUMGSequencePlayMode                          PlayMode;                                          // 0x0014(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15[0x3];                                       // 0x0015(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         PlaybackSpeed;                                     // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRestoreState;                                     // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UUMGSequencePlayer*                     ReturnValue;                                       // 0x0020(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_PlayAnimationTimeRange) == 0x000008, "Wrong alignment on UserWidget_PlayAnimationTimeRange");
static_assert(sizeof(UserWidget_PlayAnimationTimeRange) == 0x000028, "Wrong size on UserWidget_PlayAnimationTimeRange");
static_assert(offsetof(UserWidget_PlayAnimationTimeRange, InAnimation) == 0x000000, "Member 'UserWidget_PlayAnimationTimeRange::InAnimation' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationTimeRange, StartAtTime) == 0x000008, "Member 'UserWidget_PlayAnimationTimeRange::StartAtTime' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationTimeRange, EndAtTime) == 0x00000C, "Member 'UserWidget_PlayAnimationTimeRange::EndAtTime' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationTimeRange, NumLoopsToPlay) == 0x000010, "Member 'UserWidget_PlayAnimationTimeRange::NumLoopsToPlay' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationTimeRange, PlayMode) == 0x000014, "Member 'UserWidget_PlayAnimationTimeRange::PlayMode' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationTimeRange, PlaybackSpeed) == 0x000018, "Member 'UserWidget_PlayAnimationTimeRange::PlaybackSpeed' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationTimeRange, bRestoreState) == 0x00001C, "Member 'UserWidget_PlayAnimationTimeRange::bRestoreState' has a wrong offset!");
static_assert(offsetof(UserWidget_PlayAnimationTimeRange, ReturnValue) == 0x000020, "Member 'UserWidget_PlayAnimationTimeRange::ReturnValue' has a wrong offset!");

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

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

// Function UMG.UserWidget.ReverseAnimation
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_ReverseAnimation final
{
public:
	const class UWidgetAnimation*                 InAnimation;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_ReverseAnimation) == 0x000008, "Wrong alignment on UserWidget_ReverseAnimation");
static_assert(sizeof(UserWidget_ReverseAnimation) == 0x000008, "Wrong size on UserWidget_ReverseAnimation");
static_assert(offsetof(UserWidget_ReverseAnimation, InAnimation) == 0x000000, "Member 'UserWidget_ReverseAnimation::InAnimation' has a wrong offset!");

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

// Function UMG.UserWidget.SetAnchorsInViewport
// 0x0010 (0x0010 - 0x0000)
struct UserWidget_SetAnchorsInViewport final
{
public:
	struct FAnchors                               Anchors;                                           // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_SetAnchorsInViewport) == 0x000004, "Wrong alignment on UserWidget_SetAnchorsInViewport");
static_assert(sizeof(UserWidget_SetAnchorsInViewport) == 0x000010, "Wrong size on UserWidget_SetAnchorsInViewport");
static_assert(offsetof(UserWidget_SetAnchorsInViewport, Anchors) == 0x000000, "Member 'UserWidget_SetAnchorsInViewport::Anchors' has a wrong offset!");

// Function UMG.UserWidget.SetAnimationCurrentTime
// 0x0010 (0x0010 - 0x0000)
struct UserWidget_SetAnimationCurrentTime final
{
public:
	const class UWidgetAnimation*                 InAnimation;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InTime;                                            // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(UserWidget_SetAnimationCurrentTime) == 0x000008, "Wrong alignment on UserWidget_SetAnimationCurrentTime");
static_assert(sizeof(UserWidget_SetAnimationCurrentTime) == 0x000010, "Wrong size on UserWidget_SetAnimationCurrentTime");
static_assert(offsetof(UserWidget_SetAnimationCurrentTime, InAnimation) == 0x000000, "Member 'UserWidget_SetAnimationCurrentTime::InAnimation' has a wrong offset!");
static_assert(offsetof(UserWidget_SetAnimationCurrentTime, InTime) == 0x000008, "Member 'UserWidget_SetAnimationCurrentTime::InTime' has a wrong offset!");

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

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

// Function UMG.UserWidget.SetForegroundColor
// 0x0028 (0x0028 - 0x0000)
struct UserWidget_SetForegroundColor final
{
public:
	struct FSlateColor                            InForegroundColor;                                 // 0x0000(0x0028)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_SetForegroundColor) == 0x000008, "Wrong alignment on UserWidget_SetForegroundColor");
static_assert(sizeof(UserWidget_SetForegroundColor) == 0x000028, "Wrong size on UserWidget_SetForegroundColor");
static_assert(offsetof(UserWidget_SetForegroundColor, InForegroundColor) == 0x000000, "Member 'UserWidget_SetForegroundColor::InForegroundColor' has a wrong offset!");

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

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

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

// Function UMG.UserWidget.SetOwningPlayer
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_SetOwningPlayer final
{
public:
	class APlayerController*                      LocalPlayerController;                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_SetOwningPlayer) == 0x000008, "Wrong alignment on UserWidget_SetOwningPlayer");
static_assert(sizeof(UserWidget_SetOwningPlayer) == 0x000008, "Wrong size on UserWidget_SetOwningPlayer");
static_assert(offsetof(UserWidget_SetOwningPlayer, LocalPlayerController) == 0x000000, "Member 'UserWidget_SetOwningPlayer::LocalPlayerController' has a wrong offset!");

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

// Function UMG.UserWidget.SetPlaybackSpeed
// 0x0010 (0x0010 - 0x0000)
struct UserWidget_SetPlaybackSpeed final
{
public:
	const class UWidgetAnimation*                 InAnimation;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PlaybackSpeed;                                     // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(UserWidget_SetPlaybackSpeed) == 0x000008, "Wrong alignment on UserWidget_SetPlaybackSpeed");
static_assert(sizeof(UserWidget_SetPlaybackSpeed) == 0x000010, "Wrong size on UserWidget_SetPlaybackSpeed");
static_assert(offsetof(UserWidget_SetPlaybackSpeed, InAnimation) == 0x000000, "Member 'UserWidget_SetPlaybackSpeed::InAnimation' has a wrong offset!");
static_assert(offsetof(UserWidget_SetPlaybackSpeed, PlaybackSpeed) == 0x000008, "Member 'UserWidget_SetPlaybackSpeed::PlaybackSpeed' has a wrong offset!");

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

// Function UMG.UserWidget.StopAnimation
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_StopAnimation final
{
public:
	const class UWidgetAnimation*                 InAnimation;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_StopAnimation) == 0x000008, "Wrong alignment on UserWidget_StopAnimation");
static_assert(sizeof(UserWidget_StopAnimation) == 0x000008, "Wrong size on UserWidget_StopAnimation");
static_assert(offsetof(UserWidget_StopAnimation, InAnimation) == 0x000000, "Member 'UserWidget_StopAnimation::InAnimation' has a wrong offset!");

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

// Function UMG.UserWidget.Tick
// 0x003C (0x003C - 0x0000)
struct UserWidget_Tick final
{
public:
	struct FGeometry                              MyGeometry;                                        // 0x0000(0x0038)(Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         InDeltaTime;                                       // 0x0038(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_Tick) == 0x000004, "Wrong alignment on UserWidget_Tick");
static_assert(sizeof(UserWidget_Tick) == 0x00003C, "Wrong size on UserWidget_Tick");
static_assert(offsetof(UserWidget_Tick, MyGeometry) == 0x000000, "Member 'UserWidget_Tick::MyGeometry' has a wrong offset!");
static_assert(offsetof(UserWidget_Tick, InDeltaTime) == 0x000038, "Member 'UserWidget_Tick::InDeltaTime' has a wrong offset!");

// Function UMG.UserWidget.UnbindAllFromAnimationFinished
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_UnbindAllFromAnimationFinished final
{
public:
	class UWidgetAnimation*                       Animation;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_UnbindAllFromAnimationFinished) == 0x000008, "Wrong alignment on UserWidget_UnbindAllFromAnimationFinished");
static_assert(sizeof(UserWidget_UnbindAllFromAnimationFinished) == 0x000008, "Wrong size on UserWidget_UnbindAllFromAnimationFinished");
static_assert(offsetof(UserWidget_UnbindAllFromAnimationFinished, Animation) == 0x000000, "Member 'UserWidget_UnbindAllFromAnimationFinished::Animation' has a wrong offset!");

// Function UMG.UserWidget.UnbindAllFromAnimationStarted
// 0x0008 (0x0008 - 0x0000)
struct UserWidget_UnbindAllFromAnimationStarted final
{
public:
	class UWidgetAnimation*                       Animation;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_UnbindAllFromAnimationStarted) == 0x000008, "Wrong alignment on UserWidget_UnbindAllFromAnimationStarted");
static_assert(sizeof(UserWidget_UnbindAllFromAnimationStarted) == 0x000008, "Wrong size on UserWidget_UnbindAllFromAnimationStarted");
static_assert(offsetof(UserWidget_UnbindAllFromAnimationStarted, Animation) == 0x000000, "Member 'UserWidget_UnbindAllFromAnimationStarted::Animation' has a wrong offset!");

// Function UMG.UserWidget.UnbindFromAnimationFinished
// 0x0018 (0x0018 - 0x0000)
struct UserWidget_UnbindFromAnimationFinished final
{
public:
	class UWidgetAnimation*                       Animation;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             Delegate;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_UnbindFromAnimationFinished) == 0x000008, "Wrong alignment on UserWidget_UnbindFromAnimationFinished");
static_assert(sizeof(UserWidget_UnbindFromAnimationFinished) == 0x000018, "Wrong size on UserWidget_UnbindFromAnimationFinished");
static_assert(offsetof(UserWidget_UnbindFromAnimationFinished, Animation) == 0x000000, "Member 'UserWidget_UnbindFromAnimationFinished::Animation' has a wrong offset!");
static_assert(offsetof(UserWidget_UnbindFromAnimationFinished, Delegate) == 0x000008, "Member 'UserWidget_UnbindFromAnimationFinished::Delegate' has a wrong offset!");

// Function UMG.UserWidget.UnbindFromAnimationStarted
// 0x0018 (0x0018 - 0x0000)
struct UserWidget_UnbindFromAnimationStarted final
{
public:
	class UWidgetAnimation*                       Animation;                                         // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             Delegate;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_UnbindFromAnimationStarted) == 0x000008, "Wrong alignment on UserWidget_UnbindFromAnimationStarted");
static_assert(sizeof(UserWidget_UnbindFromAnimationStarted) == 0x000018, "Wrong size on UserWidget_UnbindFromAnimationStarted");
static_assert(offsetof(UserWidget_UnbindFromAnimationStarted, Animation) == 0x000000, "Member 'UserWidget_UnbindFromAnimationStarted::Animation' has a wrong offset!");
static_assert(offsetof(UserWidget_UnbindFromAnimationStarted, Delegate) == 0x000008, "Member 'UserWidget_UnbindFromAnimationStarted::Delegate' has a wrong offset!");

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

// Function UMG.UserWidget.GetAnchorsInViewport
// 0x0010 (0x0010 - 0x0000)
struct UserWidget_GetAnchorsInViewport final
{
public:
	struct FAnchors                               ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_GetAnchorsInViewport) == 0x000004, "Wrong alignment on UserWidget_GetAnchorsInViewport");
static_assert(sizeof(UserWidget_GetAnchorsInViewport) == 0x000010, "Wrong size on UserWidget_GetAnchorsInViewport");
static_assert(offsetof(UserWidget_GetAnchorsInViewport, ReturnValue) == 0x000000, "Member 'UserWidget_GetAnchorsInViewport::ReturnValue' has a wrong offset!");

// Function UMG.UserWidget.GetAnimationCurrentTime
// 0x0010 (0x0010 - 0x0000)
struct UserWidget_GetAnimationCurrentTime final
{
public:
	const class UWidgetAnimation*                 InAnimation;                                       // 0x0000(0x0008)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(UserWidget_GetAnimationCurrentTime) == 0x000008, "Wrong alignment on UserWidget_GetAnimationCurrentTime");
static_assert(sizeof(UserWidget_GetAnimationCurrentTime) == 0x000010, "Wrong size on UserWidget_GetAnimationCurrentTime");
static_assert(offsetof(UserWidget_GetAnimationCurrentTime, InAnimation) == 0x000000, "Member 'UserWidget_GetAnimationCurrentTime::InAnimation' has a wrong offset!");
static_assert(offsetof(UserWidget_GetAnimationCurrentTime, ReturnValue) == 0x000008, "Member 'UserWidget_GetAnimationCurrentTime::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

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

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

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

// Function UMG.UserWidget.OnPaint
// 0x0030 (0x0030 - 0x0000)
struct UserWidget_OnPaint final
{
public:
	struct FPaintContext                          Context;                                           // 0x0000(0x0030)(Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserWidget_OnPaint) == 0x000008, "Wrong alignment on UserWidget_OnPaint");
static_assert(sizeof(UserWidget_OnPaint) == 0x000030, "Wrong size on UserWidget_OnPaint");
static_assert(offsetof(UserWidget_OnPaint, Context) == 0x000000, "Member 'UserWidget_OnPaint::Context' has a wrong offset!");

// Function UMG.TextLayoutWidget.SetJustification
// 0x0001 (0x0001 - 0x0000)
struct TextLayoutWidget_SetJustification final
{
public:
	ETextJustify                                  InJustification;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TextLayoutWidget_SetJustification) == 0x000001, "Wrong alignment on TextLayoutWidget_SetJustification");
static_assert(sizeof(TextLayoutWidget_SetJustification) == 0x000001, "Wrong size on TextLayoutWidget_SetJustification");
static_assert(offsetof(TextLayoutWidget_SetJustification, InJustification) == 0x000000, "Member 'TextLayoutWidget_SetJustification::InJustification' has a wrong offset!");

// Function UMG.MultiLineEditableText.SetHintText
// 0x0018 (0x0018 - 0x0000)
struct MultiLineEditableText_SetHintText final
{
public:
	class FText                                   InHintText;                                        // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(MultiLineEditableText_SetHintText) == 0x000008, "Wrong alignment on MultiLineEditableText_SetHintText");
static_assert(sizeof(MultiLineEditableText_SetHintText) == 0x000018, "Wrong size on MultiLineEditableText_SetHintText");
static_assert(offsetof(MultiLineEditableText_SetHintText, InHintText) == 0x000000, "Member 'MultiLineEditableText_SetHintText::InHintText' has a wrong offset!");

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

// Function UMG.MultiLineEditableText.SetText
// 0x0018 (0x0018 - 0x0000)
struct MultiLineEditableText_SetText final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(MultiLineEditableText_SetText) == 0x000008, "Wrong alignment on MultiLineEditableText_SetText");
static_assert(sizeof(MultiLineEditableText_SetText) == 0x000018, "Wrong size on MultiLineEditableText_SetText");
static_assert(offsetof(MultiLineEditableText_SetText, InText) == 0x000000, "Member 'MultiLineEditableText_SetText::InText' has a wrong offset!");

// Function UMG.MultiLineEditableText.SetWidgetStyle
// 0x0270 (0x0270 - 0x0000)
struct MultiLineEditableText_SetWidgetStyle final
{
public:
	struct FTextBlockStyle                        InWidgetStyle;                                     // 0x0000(0x0270)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(MultiLineEditableText_SetWidgetStyle) == 0x000008, "Wrong alignment on MultiLineEditableText_SetWidgetStyle");
static_assert(sizeof(MultiLineEditableText_SetWidgetStyle) == 0x000270, "Wrong size on MultiLineEditableText_SetWidgetStyle");
static_assert(offsetof(MultiLineEditableText_SetWidgetStyle, InWidgetStyle) == 0x000000, "Member 'MultiLineEditableText_SetWidgetStyle::InWidgetStyle' has a wrong offset!");

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

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

// Function UMG.RichTextBlock.GetDecoratorByClass
// 0x0010 (0x0010 - 0x0000)
struct RichTextBlock_GetDecoratorByClass final
{
public:
	TSubclassOf<class URichTextBlockDecorator>    DecoratorClass;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class URichTextBlockDecorator*                ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RichTextBlock_GetDecoratorByClass) == 0x000008, "Wrong alignment on RichTextBlock_GetDecoratorByClass");
static_assert(sizeof(RichTextBlock_GetDecoratorByClass) == 0x000010, "Wrong size on RichTextBlock_GetDecoratorByClass");
static_assert(offsetof(RichTextBlock_GetDecoratorByClass, DecoratorClass) == 0x000000, "Member 'RichTextBlock_GetDecoratorByClass::DecoratorClass' has a wrong offset!");
static_assert(offsetof(RichTextBlock_GetDecoratorByClass, ReturnValue) == 0x000008, "Member 'RichTextBlock_GetDecoratorByClass::ReturnValue' has a wrong offset!");

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

// Function UMG.RichTextBlock.SetDefaultColorAndOpacity
// 0x0028 (0x0028 - 0x0000)
struct RichTextBlock_SetDefaultColorAndOpacity final
{
public:
	struct FSlateColor                            InColorAndOpacity;                                 // 0x0000(0x0028)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(RichTextBlock_SetDefaultColorAndOpacity) == 0x000008, "Wrong alignment on RichTextBlock_SetDefaultColorAndOpacity");
static_assert(sizeof(RichTextBlock_SetDefaultColorAndOpacity) == 0x000028, "Wrong size on RichTextBlock_SetDefaultColorAndOpacity");
static_assert(offsetof(RichTextBlock_SetDefaultColorAndOpacity, InColorAndOpacity) == 0x000000, "Member 'RichTextBlock_SetDefaultColorAndOpacity::InColorAndOpacity' has a wrong offset!");

// Function UMG.RichTextBlock.SetDefaultFont
// 0x0058 (0x0058 - 0x0000)
struct RichTextBlock_SetDefaultFont final
{
public:
	struct FSlateFontInfo                         InFontInfo;                                        // 0x0000(0x0058)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RichTextBlock_SetDefaultFont) == 0x000008, "Wrong alignment on RichTextBlock_SetDefaultFont");
static_assert(sizeof(RichTextBlock_SetDefaultFont) == 0x000058, "Wrong size on RichTextBlock_SetDefaultFont");
static_assert(offsetof(RichTextBlock_SetDefaultFont, InFontInfo) == 0x000000, "Member 'RichTextBlock_SetDefaultFont::InFontInfo' has a wrong offset!");

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

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

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

// Function UMG.RichTextBlock.SetDefaultTextStyle
// 0x0270 (0x0270 - 0x0000)
struct RichTextBlock_SetDefaultTextStyle final
{
public:
	struct FTextBlockStyle                        InDefaultTextStyle;                                // 0x0000(0x0270)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(RichTextBlock_SetDefaultTextStyle) == 0x000008, "Wrong alignment on RichTextBlock_SetDefaultTextStyle");
static_assert(sizeof(RichTextBlock_SetDefaultTextStyle) == 0x000270, "Wrong size on RichTextBlock_SetDefaultTextStyle");
static_assert(offsetof(RichTextBlock_SetDefaultTextStyle, InDefaultTextStyle) == 0x000000, "Member 'RichTextBlock_SetDefaultTextStyle::InDefaultTextStyle' has a wrong offset!");

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

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

// Function UMG.RichTextBlock.SetTextStyleSet
// 0x0008 (0x0008 - 0x0000)
struct RichTextBlock_SetTextStyleSet final
{
public:
	class UDataTable*                             NewTextStyleSet;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RichTextBlock_SetTextStyleSet) == 0x000008, "Wrong alignment on RichTextBlock_SetTextStyleSet");
static_assert(sizeof(RichTextBlock_SetTextStyleSet) == 0x000008, "Wrong size on RichTextBlock_SetTextStyleSet");
static_assert(offsetof(RichTextBlock_SetTextStyleSet, NewTextStyleSet) == 0x000000, "Member 'RichTextBlock_SetTextStyleSet::NewTextStyleSet' has a wrong offset!");

// Function UMG.RichTextBlock.SetTextTransformPolicy
// 0x0001 (0x0001 - 0x0000)
struct RichTextBlock_SetTextTransformPolicy final
{
public:
	ETextTransformPolicy                          InTransformPolicy;                                 // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RichTextBlock_SetTextTransformPolicy) == 0x000001, "Wrong alignment on RichTextBlock_SetTextTransformPolicy");
static_assert(sizeof(RichTextBlock_SetTextTransformPolicy) == 0x000001, "Wrong size on RichTextBlock_SetTextTransformPolicy");
static_assert(offsetof(RichTextBlock_SetTextTransformPolicy, InTransformPolicy) == 0x000000, "Member 'RichTextBlock_SetTextTransformPolicy::InTransformPolicy' has a wrong offset!");

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

// Function UMG.GridPanel.AddChildToGrid
// 0x0018 (0x0018 - 0x0000)
struct GridPanel_AddChildToGrid final
{
public:
	class UWidget*                                Content;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InRow;                                             // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InColumn;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UGridSlot*                              ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GridPanel_AddChildToGrid) == 0x000008, "Wrong alignment on GridPanel_AddChildToGrid");
static_assert(sizeof(GridPanel_AddChildToGrid) == 0x000018, "Wrong size on GridPanel_AddChildToGrid");
static_assert(offsetof(GridPanel_AddChildToGrid, Content) == 0x000000, "Member 'GridPanel_AddChildToGrid::Content' has a wrong offset!");
static_assert(offsetof(GridPanel_AddChildToGrid, InRow) == 0x000008, "Member 'GridPanel_AddChildToGrid::InRow' has a wrong offset!");
static_assert(offsetof(GridPanel_AddChildToGrid, InColumn) == 0x00000C, "Member 'GridPanel_AddChildToGrid::InColumn' has a wrong offset!");
static_assert(offsetof(GridPanel_AddChildToGrid, ReturnValue) == 0x000010, "Member 'GridPanel_AddChildToGrid::ReturnValue' has a wrong offset!");

// Function UMG.GridPanel.SetColumnFill
// 0x0008 (0x0008 - 0x0000)
struct GridPanel_SetColumnFill final
{
public:
	int32                                         ColumnIndex;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Coefficient;                                       // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GridPanel_SetColumnFill) == 0x000004, "Wrong alignment on GridPanel_SetColumnFill");
static_assert(sizeof(GridPanel_SetColumnFill) == 0x000008, "Wrong size on GridPanel_SetColumnFill");
static_assert(offsetof(GridPanel_SetColumnFill, ColumnIndex) == 0x000000, "Member 'GridPanel_SetColumnFill::ColumnIndex' has a wrong offset!");
static_assert(offsetof(GridPanel_SetColumnFill, Coefficient) == 0x000004, "Member 'GridPanel_SetColumnFill::Coefficient' has a wrong offset!");

// Function UMG.GridPanel.SetRowFill
// 0x0008 (0x0008 - 0x0000)
struct GridPanel_SetRowFill final
{
public:
	int32                                         ColumnIndex;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Coefficient;                                       // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(GridPanel_SetRowFill) == 0x000004, "Wrong alignment on GridPanel_SetRowFill");
static_assert(sizeof(GridPanel_SetRowFill) == 0x000008, "Wrong size on GridPanel_SetRowFill");
static_assert(offsetof(GridPanel_SetRowFill, ColumnIndex) == 0x000000, "Member 'GridPanel_SetRowFill::ColumnIndex' has a wrong offset!");
static_assert(offsetof(GridPanel_SetRowFill, Coefficient) == 0x000004, "Member 'GridPanel_SetRowFill::Coefficient' has a wrong offset!");

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

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

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

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

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

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

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

// Function UMG.Button.SetStyle
// 0x0278 (0x0278 - 0x0000)
struct Button_SetStyle final
{
public:
	struct FButtonStyle                           InStyle;                                           // 0x0000(0x0278)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(Button_SetStyle) == 0x000008, "Wrong alignment on Button_SetStyle");
static_assert(sizeof(Button_SetStyle) == 0x000278, "Wrong size on Button_SetStyle");
static_assert(offsetof(Button_SetStyle, InStyle) == 0x000000, "Member 'Button_SetStyle::InStyle' has a wrong offset!");

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

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

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

// Function UMG.Image.SetBrush
// 0x0088 (0x0088 - 0x0000)
struct Image_SetBrush final
{
public:
	struct FSlateBrush                            InBrush;                                           // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(Image_SetBrush) == 0x000008, "Wrong alignment on Image_SetBrush");
static_assert(sizeof(Image_SetBrush) == 0x000088, "Wrong size on Image_SetBrush");
static_assert(offsetof(Image_SetBrush, InBrush) == 0x000000, "Member 'Image_SetBrush::InBrush' has a wrong offset!");

// Function UMG.Image.SetBrushFromAsset
// 0x0008 (0x0008 - 0x0000)
struct Image_SetBrushFromAsset final
{
public:
	class USlateBrushAsset*                       Asset;                                             // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Image_SetBrushFromAsset) == 0x000008, "Wrong alignment on Image_SetBrushFromAsset");
static_assert(sizeof(Image_SetBrushFromAsset) == 0x000008, "Wrong size on Image_SetBrushFromAsset");
static_assert(offsetof(Image_SetBrushFromAsset, Asset) == 0x000000, "Member 'Image_SetBrushFromAsset::Asset' has a wrong offset!");

// Function UMG.Image.SetBrushFromAtlasInterface
// 0x0018 (0x0018 - 0x0000)
struct Image_SetBrushFromAtlasInterface final
{
public:
	TScriptInterface<class ISlateTextureAtlasInterface> AtlasRegion;                                 // 0x0000(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          bMatchSize;                                        // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(Image_SetBrushFromAtlasInterface) == 0x000008, "Wrong alignment on Image_SetBrushFromAtlasInterface");
static_assert(sizeof(Image_SetBrushFromAtlasInterface) == 0x000018, "Wrong size on Image_SetBrushFromAtlasInterface");
static_assert(offsetof(Image_SetBrushFromAtlasInterface, AtlasRegion) == 0x000000, "Member 'Image_SetBrushFromAtlasInterface::AtlasRegion' has a wrong offset!");
static_assert(offsetof(Image_SetBrushFromAtlasInterface, bMatchSize) == 0x000010, "Member 'Image_SetBrushFromAtlasInterface::bMatchSize' has a wrong offset!");

// Function UMG.Image.SetBrushFromMaterial
// 0x0008 (0x0008 - 0x0000)
struct Image_SetBrushFromMaterial final
{
public:
	class UMaterialInterface*                     Material;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Image_SetBrushFromMaterial) == 0x000008, "Wrong alignment on Image_SetBrushFromMaterial");
static_assert(sizeof(Image_SetBrushFromMaterial) == 0x000008, "Wrong size on Image_SetBrushFromMaterial");
static_assert(offsetof(Image_SetBrushFromMaterial, Material) == 0x000000, "Member 'Image_SetBrushFromMaterial::Material' has a wrong offset!");

// Function UMG.Image.SetBrushFromSoftMaterial
// 0x0028 (0x0028 - 0x0000)
struct Image_SetBrushFromSoftMaterial final
{
public:
	TSoftObjectPtr<class UMaterialInterface>      SoftMaterial;                                      // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Image_SetBrushFromSoftMaterial) == 0x000008, "Wrong alignment on Image_SetBrushFromSoftMaterial");
static_assert(sizeof(Image_SetBrushFromSoftMaterial) == 0x000028, "Wrong size on Image_SetBrushFromSoftMaterial");
static_assert(offsetof(Image_SetBrushFromSoftMaterial, SoftMaterial) == 0x000000, "Member 'Image_SetBrushFromSoftMaterial::SoftMaterial' has a wrong offset!");

// Function UMG.Image.SetBrushFromSoftTexture
// 0x0030 (0x0030 - 0x0000)
struct Image_SetBrushFromSoftTexture final
{
public:
	TSoftObjectPtr<class UTexture2D>              SoftTexture;                                       // 0x0000(0x0028)(Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMatchSize;                                        // 0x0028(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(Image_SetBrushFromSoftTexture) == 0x000008, "Wrong alignment on Image_SetBrushFromSoftTexture");
static_assert(sizeof(Image_SetBrushFromSoftTexture) == 0x000030, "Wrong size on Image_SetBrushFromSoftTexture");
static_assert(offsetof(Image_SetBrushFromSoftTexture, SoftTexture) == 0x000000, "Member 'Image_SetBrushFromSoftTexture::SoftTexture' has a wrong offset!");
static_assert(offsetof(Image_SetBrushFromSoftTexture, bMatchSize) == 0x000028, "Member 'Image_SetBrushFromSoftTexture::bMatchSize' has a wrong offset!");

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

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

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

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

// Function UMG.Image.SetBrushTintColor
// 0x0028 (0x0028 - 0x0000)
struct Image_SetBrushTintColor final
{
public:
	struct FSlateColor                            TintColor;                                         // 0x0000(0x0028)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(Image_SetBrushTintColor) == 0x000008, "Wrong alignment on Image_SetBrushTintColor");
static_assert(sizeof(Image_SetBrushTintColor) == 0x000028, "Wrong size on Image_SetBrushTintColor");
static_assert(offsetof(Image_SetBrushTintColor, TintColor) == 0x000000, "Member 'Image_SetBrushTintColor::TintColor' has a wrong offset!");

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

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

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

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

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

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

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

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

// Function UMG.AsyncTaskDownloadImage.DownloadImage
// 0x0018 (0x0018 - 0x0000)
struct AsyncTaskDownloadImage_DownloadImage final
{
public:
	class FString                                 URL;                                               // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAsyncTaskDownloadImage*                ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(AsyncTaskDownloadImage_DownloadImage) == 0x000008, "Wrong alignment on AsyncTaskDownloadImage_DownloadImage");
static_assert(sizeof(AsyncTaskDownloadImage_DownloadImage) == 0x000018, "Wrong size on AsyncTaskDownloadImage_DownloadImage");
static_assert(offsetof(AsyncTaskDownloadImage_DownloadImage, URL) == 0x000000, "Member 'AsyncTaskDownloadImage_DownloadImage::URL' has a wrong offset!");
static_assert(offsetof(AsyncTaskDownloadImage_DownloadImage, ReturnValue) == 0x000010, "Member 'AsyncTaskDownloadImage_DownloadImage::ReturnValue' has a wrong offset!");

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

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

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

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

// Function UMG.BackgroundBlur.SetLowQualityFallbackBrush
// 0x0088 (0x0088 - 0x0000)
struct BackgroundBlur_SetLowQualityFallbackBrush final
{
public:
	struct FSlateBrush                            InBrush;                                           // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(BackgroundBlur_SetLowQualityFallbackBrush) == 0x000008, "Wrong alignment on BackgroundBlur_SetLowQualityFallbackBrush");
static_assert(sizeof(BackgroundBlur_SetLowQualityFallbackBrush) == 0x000088, "Wrong size on BackgroundBlur_SetLowQualityFallbackBrush");
static_assert(offsetof(BackgroundBlur_SetLowQualityFallbackBrush, InBrush) == 0x000000, "Member 'BackgroundBlur_SetLowQualityFallbackBrush::InBrush' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.CanvasPanelSlot.SetAnchors
// 0x0010 (0x0010 - 0x0000)
struct CanvasPanelSlot_SetAnchors final
{
public:
	struct FAnchors                               InAnchors;                                         // 0x0000(0x0010)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CanvasPanelSlot_SetAnchors) == 0x000004, "Wrong alignment on CanvasPanelSlot_SetAnchors");
static_assert(sizeof(CanvasPanelSlot_SetAnchors) == 0x000010, "Wrong size on CanvasPanelSlot_SetAnchors");
static_assert(offsetof(CanvasPanelSlot_SetAnchors, InAnchors) == 0x000000, "Member 'CanvasPanelSlot_SetAnchors::InAnchors' has a wrong offset!");

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

// Function UMG.CanvasPanelSlot.SetLayout
// 0x0028 (0x0028 - 0x0000)
struct CanvasPanelSlot_SetLayout final
{
public:
	struct FAnchorData                            InLayoutData;                                      // 0x0000(0x0028)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CanvasPanelSlot_SetLayout) == 0x000004, "Wrong alignment on CanvasPanelSlot_SetLayout");
static_assert(sizeof(CanvasPanelSlot_SetLayout) == 0x000028, "Wrong size on CanvasPanelSlot_SetLayout");
static_assert(offsetof(CanvasPanelSlot_SetLayout, InLayoutData) == 0x000000, "Member 'CanvasPanelSlot_SetLayout::InLayoutData' has a wrong offset!");

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

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

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

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

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

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

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

// Function UMG.CanvasPanelSlot.GetAnchors
// 0x0010 (0x0010 - 0x0000)
struct CanvasPanelSlot_GetAnchors final
{
public:
	struct FAnchors                               ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CanvasPanelSlot_GetAnchors) == 0x000004, "Wrong alignment on CanvasPanelSlot_GetAnchors");
static_assert(sizeof(CanvasPanelSlot_GetAnchors) == 0x000010, "Wrong size on CanvasPanelSlot_GetAnchors");
static_assert(offsetof(CanvasPanelSlot_GetAnchors, ReturnValue) == 0x000000, "Member 'CanvasPanelSlot_GetAnchors::ReturnValue' has a wrong offset!");

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

// Function UMG.CanvasPanelSlot.GetLayout
// 0x0028 (0x0028 - 0x0000)
struct CanvasPanelSlot_GetLayout final
{
public:
	struct FAnchorData                            ReturnValue;                                       // 0x0000(0x0028)(Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(CanvasPanelSlot_GetLayout) == 0x000004, "Wrong alignment on CanvasPanelSlot_GetLayout");
static_assert(sizeof(CanvasPanelSlot_GetLayout) == 0x000028, "Wrong size on CanvasPanelSlot_GetLayout");
static_assert(offsetof(CanvasPanelSlot_GetLayout, ReturnValue) == 0x000000, "Member 'CanvasPanelSlot_GetLayout::ReturnValue' has a wrong offset!");

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

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

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

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

// Function UMG.CheckBox.SetCheckedState
// 0x0001 (0x0001 - 0x0000)
struct CheckBox_SetCheckedState final
{
public:
	ECheckBoxState                                InCheckedState;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(CheckBox_SetCheckedState) == 0x000001, "Wrong alignment on CheckBox_SetCheckedState");
static_assert(sizeof(CheckBox_SetCheckedState) == 0x000001, "Wrong size on CheckBox_SetCheckedState");
static_assert(offsetof(CheckBox_SetCheckedState, InCheckedState) == 0x000000, "Member 'CheckBox_SetCheckedState::InCheckedState' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.ColorBinding.GetSlateValue
// 0x0028 (0x0028 - 0x0000)
struct ColorBinding_GetSlateValue final
{
public:
	struct FSlateColor                            ReturnValue;                                       // 0x0000(0x0028)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(ColorBinding_GetSlateValue) == 0x000008, "Wrong alignment on ColorBinding_GetSlateValue");
static_assert(sizeof(ColorBinding_GetSlateValue) == 0x000028, "Wrong size on ColorBinding_GetSlateValue");
static_assert(offsetof(ColorBinding_GetSlateValue, ReturnValue) == 0x000000, "Member 'ColorBinding_GetSlateValue::ReturnValue' has a wrong offset!");

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

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

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

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

// Function UMG.ComboBoxString.FindOptionIndex
// 0x0018 (0x0018 - 0x0000)
struct ComboBoxString_FindOptionIndex final
{
public:
	class FString                                 Option;                                            // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0010(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(ComboBoxString_FindOptionIndex) == 0x000008, "Wrong alignment on ComboBoxString_FindOptionIndex");
static_assert(sizeof(ComboBoxString_FindOptionIndex) == 0x000018, "Wrong size on ComboBoxString_FindOptionIndex");
static_assert(offsetof(ComboBoxString_FindOptionIndex, Option) == 0x000000, "Member 'ComboBoxString_FindOptionIndex::Option' has a wrong offset!");
static_assert(offsetof(ComboBoxString_FindOptionIndex, ReturnValue) == 0x000010, "Member 'ComboBoxString_FindOptionIndex::ReturnValue' has a wrong offset!");

// Function UMG.ComboBoxString.GetOptionAtIndex
// 0x0018 (0x0018 - 0x0000)
struct ComboBoxString_GetOptionAtIndex final
{
public:
	int32                                         Index_0;                                           // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ReturnValue;                                       // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ComboBoxString_GetOptionAtIndex) == 0x000008, "Wrong alignment on ComboBoxString_GetOptionAtIndex");
static_assert(sizeof(ComboBoxString_GetOptionAtIndex) == 0x000018, "Wrong size on ComboBoxString_GetOptionAtIndex");
static_assert(offsetof(ComboBoxString_GetOptionAtIndex, Index_0) == 0x000000, "Member 'ComboBoxString_GetOptionAtIndex::Index_0' has a wrong offset!");
static_assert(offsetof(ComboBoxString_GetOptionAtIndex, ReturnValue) == 0x000008, "Member 'ComboBoxString_GetOptionAtIndex::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

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

// Function UMG.DynamicEntryBoxBase.SetEntrySpacing
// 0x0008 (0x0008 - 0x0000)
struct DynamicEntryBoxBase_SetEntrySpacing final
{
public:
	struct FVector2D                              InEntrySpacing;                                    // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(DynamicEntryBoxBase_SetEntrySpacing) == 0x000004, "Wrong alignment on DynamicEntryBoxBase_SetEntrySpacing");
static_assert(sizeof(DynamicEntryBoxBase_SetEntrySpacing) == 0x000008, "Wrong size on DynamicEntryBoxBase_SetEntrySpacing");
static_assert(offsetof(DynamicEntryBoxBase_SetEntrySpacing, InEntrySpacing) == 0x000000, "Member 'DynamicEntryBoxBase_SetEntrySpacing::InEntrySpacing' has a wrong offset!");

// Function UMG.DynamicEntryBoxBase.SetRadialSettings
// 0x0010 (0x0010 - 0x0000)
struct DynamicEntryBoxBase_SetRadialSettings final
{
public:
	struct FRadialBoxSettings                     InSettings;                                        // 0x0000(0x0010)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(DynamicEntryBoxBase_SetRadialSettings) == 0x000004, "Wrong alignment on DynamicEntryBoxBase_SetRadialSettings");
static_assert(sizeof(DynamicEntryBoxBase_SetRadialSettings) == 0x000010, "Wrong size on DynamicEntryBoxBase_SetRadialSettings");
static_assert(offsetof(DynamicEntryBoxBase_SetRadialSettings, InSettings) == 0x000000, "Member 'DynamicEntryBoxBase_SetRadialSettings::InSettings' has a wrong offset!");

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

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

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

// Function UMG.DynamicEntryBox.BP_CreateEntryOfClass
// 0x0010 (0x0010 - 0x0000)
struct DynamicEntryBox_BP_CreateEntryOfClass final
{
public:
	TSubclassOf<class UUserWidget>                EntryClass;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UUserWidget*                            ReturnValue;                                       // 0x0008(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(DynamicEntryBox_BP_CreateEntryOfClass) == 0x000008, "Wrong alignment on DynamicEntryBox_BP_CreateEntryOfClass");
static_assert(sizeof(DynamicEntryBox_BP_CreateEntryOfClass) == 0x000010, "Wrong size on DynamicEntryBox_BP_CreateEntryOfClass");
static_assert(offsetof(DynamicEntryBox_BP_CreateEntryOfClass, EntryClass) == 0x000000, "Member 'DynamicEntryBox_BP_CreateEntryOfClass::EntryClass' has a wrong offset!");
static_assert(offsetof(DynamicEntryBox_BP_CreateEntryOfClass, ReturnValue) == 0x000008, "Member 'DynamicEntryBox_BP_CreateEntryOfClass::ReturnValue' has a wrong offset!");

// Function UMG.DynamicEntryBox.RemoveEntry
// 0x0008 (0x0008 - 0x0000)
struct DynamicEntryBox_RemoveEntry final
{
public:
	class UUserWidget*                            EntryWidget;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(DynamicEntryBox_RemoveEntry) == 0x000008, "Wrong alignment on DynamicEntryBox_RemoveEntry");
static_assert(sizeof(DynamicEntryBox_RemoveEntry) == 0x000008, "Wrong size on DynamicEntryBox_RemoveEntry");
static_assert(offsetof(DynamicEntryBox_RemoveEntry, EntryWidget) == 0x000000, "Member 'DynamicEntryBox_RemoveEntry::EntryWidget' has a wrong offset!");

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

// Function UMG.EditableText.SetHintText
// 0x0018 (0x0018 - 0x0000)
struct EditableText_SetHintText final
{
public:
	class FText                                   InHintText;                                        // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(EditableText_SetHintText) == 0x000008, "Wrong alignment on EditableText_SetHintText");
static_assert(sizeof(EditableText_SetHintText) == 0x000018, "Wrong size on EditableText_SetHintText");
static_assert(offsetof(EditableText_SetHintText, InHintText) == 0x000000, "Member 'EditableText_SetHintText::InHintText' has a wrong offset!");

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

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

// Function UMG.EditableText.SetJustification
// 0x0001 (0x0001 - 0x0000)
struct EditableText_SetJustification final
{
public:
	ETextJustify                                  InJustification;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EditableText_SetJustification) == 0x000001, "Wrong alignment on EditableText_SetJustification");
static_assert(sizeof(EditableText_SetJustification) == 0x000001, "Wrong size on EditableText_SetJustification");
static_assert(offsetof(EditableText_SetJustification, InJustification) == 0x000000, "Member 'EditableText_SetJustification::InJustification' has a wrong offset!");

// Function UMG.EditableText.SetText
// 0x0018 (0x0018 - 0x0000)
struct EditableText_SetText final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(EditableText_SetText) == 0x000008, "Wrong alignment on EditableText_SetText");
static_assert(sizeof(EditableText_SetText) == 0x000018, "Wrong size on EditableText_SetText");
static_assert(offsetof(EditableText_SetText, InText) == 0x000000, "Member 'EditableText_SetText::InText' has a wrong offset!");

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

// Function UMG.EditableTextBox.SetError
// 0x0018 (0x0018 - 0x0000)
struct EditableTextBox_SetError final
{
public:
	class FText                                   InError;                                           // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(EditableTextBox_SetError) == 0x000008, "Wrong alignment on EditableTextBox_SetError");
static_assert(sizeof(EditableTextBox_SetError) == 0x000018, "Wrong size on EditableTextBox_SetError");
static_assert(offsetof(EditableTextBox_SetError, InError) == 0x000000, "Member 'EditableTextBox_SetError::InError' has a wrong offset!");

// Function UMG.EditableTextBox.SetHintText
// 0x0018 (0x0018 - 0x0000)
struct EditableTextBox_SetHintText final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(EditableTextBox_SetHintText) == 0x000008, "Wrong alignment on EditableTextBox_SetHintText");
static_assert(sizeof(EditableTextBox_SetHintText) == 0x000018, "Wrong size on EditableTextBox_SetHintText");
static_assert(offsetof(EditableTextBox_SetHintText, InText) == 0x000000, "Member 'EditableTextBox_SetHintText::InText' has a wrong offset!");

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

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

// Function UMG.EditableTextBox.SetJustification
// 0x0001 (0x0001 - 0x0000)
struct EditableTextBox_SetJustification final
{
public:
	ETextJustify                                  InJustification;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(EditableTextBox_SetJustification) == 0x000001, "Wrong alignment on EditableTextBox_SetJustification");
static_assert(sizeof(EditableTextBox_SetJustification) == 0x000001, "Wrong size on EditableTextBox_SetJustification");
static_assert(offsetof(EditableTextBox_SetJustification, InJustification) == 0x000000, "Member 'EditableTextBox_SetJustification::InJustification' has a wrong offset!");

// Function UMG.EditableTextBox.SetText
// 0x0018 (0x0018 - 0x0000)
struct EditableTextBox_SetText final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(EditableTextBox_SetText) == 0x000008, "Wrong alignment on EditableTextBox_SetText");
static_assert(sizeof(EditableTextBox_SetText) == 0x000018, "Wrong size on EditableTextBox_SetText");
static_assert(offsetof(EditableTextBox_SetText, InText) == 0x000000, "Member 'EditableTextBox_SetText::InText' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.HorizontalBoxSlot.SetSize
// 0x0008 (0x0008 - 0x0000)
struct HorizontalBoxSlot_SetSize final
{
public:
	struct FSlateChildSize                        InSize;                                            // 0x0000(0x0008)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(HorizontalBoxSlot_SetSize) == 0x000004, "Wrong alignment on HorizontalBoxSlot_SetSize");
static_assert(sizeof(HorizontalBoxSlot_SetSize) == 0x000008, "Wrong size on HorizontalBoxSlot_SetSize");
static_assert(offsetof(HorizontalBoxSlot_SetSize, InSize) == 0x000000, "Member 'HorizontalBoxSlot_SetSize::InSize' has a wrong offset!");

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

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

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

// Function UMG.InputKeySelector.SetEscapeKeys
// 0x0010 (0x0010 - 0x0000)
struct InputKeySelector_SetEscapeKeys final
{
public:
	TArray<struct FKey>                           InKeys;                                            // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InputKeySelector_SetEscapeKeys) == 0x000008, "Wrong alignment on InputKeySelector_SetEscapeKeys");
static_assert(sizeof(InputKeySelector_SetEscapeKeys) == 0x000010, "Wrong size on InputKeySelector_SetEscapeKeys");
static_assert(offsetof(InputKeySelector_SetEscapeKeys, InKeys) == 0x000000, "Member 'InputKeySelector_SetEscapeKeys::InKeys' has a wrong offset!");

// Function UMG.InputKeySelector.SetKeySelectionText
// 0x0018 (0x0018 - 0x0000)
struct InputKeySelector_SetKeySelectionText final
{
public:
	class FText                                   InKeySelectionText;                                // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InputKeySelector_SetKeySelectionText) == 0x000008, "Wrong alignment on InputKeySelector_SetKeySelectionText");
static_assert(sizeof(InputKeySelector_SetKeySelectionText) == 0x000018, "Wrong size on InputKeySelector_SetKeySelectionText");
static_assert(offsetof(InputKeySelector_SetKeySelectionText, InKeySelectionText) == 0x000000, "Member 'InputKeySelector_SetKeySelectionText::InKeySelectionText' has a wrong offset!");

// Function UMG.InputKeySelector.SetNoKeySpecifiedText
// 0x0018 (0x0018 - 0x0000)
struct InputKeySelector_SetNoKeySpecifiedText final
{
public:
	class FText                                   InNoKeySpecifiedText;                              // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(InputKeySelector_SetNoKeySpecifiedText) == 0x000008, "Wrong alignment on InputKeySelector_SetNoKeySpecifiedText");
static_assert(sizeof(InputKeySelector_SetNoKeySpecifiedText) == 0x000018, "Wrong size on InputKeySelector_SetNoKeySpecifiedText");
static_assert(offsetof(InputKeySelector_SetNoKeySpecifiedText, InNoKeySpecifiedText) == 0x000000, "Member 'InputKeySelector_SetNoKeySpecifiedText::InNoKeySpecifiedText' has a wrong offset!");

// Function UMG.InputKeySelector.SetSelectedKey
// 0x0020 (0x0020 - 0x0000)
struct InputKeySelector_SetSelectedKey final
{
public:
	struct FInputChord                            InSelectedKey;                                     // 0x0000(0x0020)(ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InputKeySelector_SetSelectedKey) == 0x000008, "Wrong alignment on InputKeySelector_SetSelectedKey");
static_assert(sizeof(InputKeySelector_SetSelectedKey) == 0x000020, "Wrong size on InputKeySelector_SetSelectedKey");
static_assert(offsetof(InputKeySelector_SetSelectedKey, InSelectedKey) == 0x000000, "Member 'InputKeySelector_SetSelectedKey::InSelectedKey' has a wrong offset!");

// Function UMG.InputKeySelector.SetTextBlockVisibility
// 0x0001 (0x0001 - 0x0000)
struct InputKeySelector_SetTextBlockVisibility final
{
public:
	ESlateVisibility                              InVisibility;                                      // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(InputKeySelector_SetTextBlockVisibility) == 0x000001, "Wrong alignment on InputKeySelector_SetTextBlockVisibility");
static_assert(sizeof(InputKeySelector_SetTextBlockVisibility) == 0x000001, "Wrong size on InputKeySelector_SetTextBlockVisibility");
static_assert(offsetof(InputKeySelector_SetTextBlockVisibility, InVisibility) == 0x000000, "Member 'InputKeySelector_SetTextBlockVisibility::InVisibility' has a wrong offset!");

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

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

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

// Function UMG.UserListEntryLibrary.GetOwningListView
// 0x0018 (0x0018 - 0x0000)
struct UserListEntryLibrary_GetOwningListView final
{
public:
	TScriptInterface<class IUserListEntry>        UserListEntry;                                     // 0x0000(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
	class UListViewBase*                          ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserListEntryLibrary_GetOwningListView) == 0x000008, "Wrong alignment on UserListEntryLibrary_GetOwningListView");
static_assert(sizeof(UserListEntryLibrary_GetOwningListView) == 0x000018, "Wrong size on UserListEntryLibrary_GetOwningListView");
static_assert(offsetof(UserListEntryLibrary_GetOwningListView, UserListEntry) == 0x000000, "Member 'UserListEntryLibrary_GetOwningListView::UserListEntry' has a wrong offset!");
static_assert(offsetof(UserListEntryLibrary_GetOwningListView, ReturnValue) == 0x000010, "Member 'UserListEntryLibrary_GetOwningListView::ReturnValue' has a wrong offset!");

// Function UMG.UserListEntryLibrary.IsListItemExpanded
// 0x0018 (0x0018 - 0x0000)
struct UserListEntryLibrary_IsListItemExpanded final
{
public:
	TScriptInterface<class IUserListEntry>        UserListEntry;                                     // 0x0000(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(UserListEntryLibrary_IsListItemExpanded) == 0x000008, "Wrong alignment on UserListEntryLibrary_IsListItemExpanded");
static_assert(sizeof(UserListEntryLibrary_IsListItemExpanded) == 0x000018, "Wrong size on UserListEntryLibrary_IsListItemExpanded");
static_assert(offsetof(UserListEntryLibrary_IsListItemExpanded, UserListEntry) == 0x000000, "Member 'UserListEntryLibrary_IsListItemExpanded::UserListEntry' has a wrong offset!");
static_assert(offsetof(UserListEntryLibrary_IsListItemExpanded, ReturnValue) == 0x000010, "Member 'UserListEntryLibrary_IsListItemExpanded::ReturnValue' has a wrong offset!");

// Function UMG.UserListEntryLibrary.IsListItemSelected
// 0x0018 (0x0018 - 0x0000)
struct UserListEntryLibrary_IsListItemSelected final
{
public:
	TScriptInterface<class IUserListEntry>        UserListEntry;                                     // 0x0000(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(UserListEntryLibrary_IsListItemSelected) == 0x000008, "Wrong alignment on UserListEntryLibrary_IsListItemSelected");
static_assert(sizeof(UserListEntryLibrary_IsListItemSelected) == 0x000018, "Wrong size on UserListEntryLibrary_IsListItemSelected");
static_assert(offsetof(UserListEntryLibrary_IsListItemSelected, UserListEntry) == 0x000000, "Member 'UserListEntryLibrary_IsListItemSelected::UserListEntry' has a wrong offset!");
static_assert(offsetof(UserListEntryLibrary_IsListItemSelected, ReturnValue) == 0x000010, "Member 'UserListEntryLibrary_IsListItemSelected::ReturnValue' has a wrong offset!");

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

// Function UMG.UserObjectListEntryLibrary.GetListItemObject
// 0x0018 (0x0018 - 0x0000)
struct UserObjectListEntryLibrary_GetListItemObject final
{
public:
	TScriptInterface<class IUserObjectListEntry>  UserObjectListEntry;                               // 0x0000(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
	class UObject*                                ReturnValue;                                       // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UserObjectListEntryLibrary_GetListItemObject) == 0x000008, "Wrong alignment on UserObjectListEntryLibrary_GetListItemObject");
static_assert(sizeof(UserObjectListEntryLibrary_GetListItemObject) == 0x000018, "Wrong size on UserObjectListEntryLibrary_GetListItemObject");
static_assert(offsetof(UserObjectListEntryLibrary_GetListItemObject, UserObjectListEntry) == 0x000000, "Member 'UserObjectListEntryLibrary_GetListItemObject::UserObjectListEntry' has a wrong offset!");
static_assert(offsetof(UserObjectListEntryLibrary_GetListItemObject, ReturnValue) == 0x000010, "Member 'UserObjectListEntryLibrary_GetListItemObject::ReturnValue' has a wrong offset!");

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

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

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

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

// Function UMG.ListView.BP_SetListItems
// 0x0010 (0x0010 - 0x0000)
struct ListView_BP_SetListItems final
{
public:
	TArray<class UObject*>                        InListItems;                                       // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(ListView_BP_SetListItems) == 0x000008, "Wrong alignment on ListView_BP_SetListItems");
static_assert(sizeof(ListView_BP_SetListItems) == 0x000010, "Wrong size on ListView_BP_SetListItems");
static_assert(offsetof(ListView_BP_SetListItems, InListItems) == 0x000000, "Member 'ListView_BP_SetListItems::InListItems' has a wrong offset!");

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

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

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

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

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

// Function UMG.ListView.SetSelectionMode
// 0x0001 (0x0001 - 0x0000)
struct ListView_SetSelectionMode final
{
public:
	ESelectionMode                                SelectionMode_0;                                   // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ListView_SetSelectionMode) == 0x000001, "Wrong alignment on ListView_SetSelectionMode");
static_assert(sizeof(ListView_SetSelectionMode) == 0x000001, "Wrong size on ListView_SetSelectionMode");
static_assert(offsetof(ListView_SetSelectionMode, SelectionMode_0) == 0x000000, "Member 'ListView_SetSelectionMode::SelectionMode_0' has a wrong offset!");

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

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

// Function UMG.ListView.BP_GetSelectedItems
// 0x0018 (0x0018 - 0x0000)
struct ListView_BP_GetSelectedItems final
{
public:
	TArray<class UObject*>                        Items;                                             // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(ListView_BP_GetSelectedItems) == 0x000008, "Wrong alignment on ListView_BP_GetSelectedItems");
static_assert(sizeof(ListView_BP_GetSelectedItems) == 0x000018, "Wrong size on ListView_BP_GetSelectedItems");
static_assert(offsetof(ListView_BP_GetSelectedItems, Items) == 0x000000, "Member 'ListView_BP_GetSelectedItems::Items' has a wrong offset!");
static_assert(offsetof(ListView_BP_GetSelectedItems, ReturnValue) == 0x000010, "Member 'ListView_BP_GetSelectedItems::ReturnValue' has a wrong offset!");

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

// Function UMG.ListView.GetIndexForItem
// 0x0010 (0x0010 - 0x0000)
struct ListView_GetIndexForItem final
{
public:
	class UObject*                                Item;                                              // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(ListView_GetIndexForItem) == 0x000008, "Wrong alignment on ListView_GetIndexForItem");
static_assert(sizeof(ListView_GetIndexForItem) == 0x000010, "Wrong size on ListView_GetIndexForItem");
static_assert(offsetof(ListView_GetIndexForItem, Item) == 0x000000, "Member 'ListView_GetIndexForItem::Item' has a wrong offset!");
static_assert(offsetof(ListView_GetIndexForItem, ReturnValue) == 0x000008, "Member 'ListView_GetIndexForItem::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

// Function UMG.MenuAnchor.SetPlacement
// 0x0001 (0x0001 - 0x0000)
struct MenuAnchor_SetPlacement final
{
public:
	EMenuPlacement                                InPlacement;                                       // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(MenuAnchor_SetPlacement) == 0x000001, "Wrong alignment on MenuAnchor_SetPlacement");
static_assert(sizeof(MenuAnchor_SetPlacement) == 0x000001, "Wrong size on MenuAnchor_SetPlacement");
static_assert(offsetof(MenuAnchor_SetPlacement, InPlacement) == 0x000000, "Member 'MenuAnchor_SetPlacement::InPlacement' has a wrong offset!");

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

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

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

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

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

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

// Function UMG.MultiLineEditableTextBox.SetError
// 0x0018 (0x0018 - 0x0000)
struct MultiLineEditableTextBox_SetError final
{
public:
	class FText                                   InError;                                           // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(MultiLineEditableTextBox_SetError) == 0x000008, "Wrong alignment on MultiLineEditableTextBox_SetError");
static_assert(sizeof(MultiLineEditableTextBox_SetError) == 0x000018, "Wrong size on MultiLineEditableTextBox_SetError");
static_assert(offsetof(MultiLineEditableTextBox_SetError, InError) == 0x000000, "Member 'MultiLineEditableTextBox_SetError::InError' has a wrong offset!");

// Function UMG.MultiLineEditableTextBox.SetHintText
// 0x0018 (0x0018 - 0x0000)
struct MultiLineEditableTextBox_SetHintText final
{
public:
	class FText                                   InHintText;                                        // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(MultiLineEditableTextBox_SetHintText) == 0x000008, "Wrong alignment on MultiLineEditableTextBox_SetHintText");
static_assert(sizeof(MultiLineEditableTextBox_SetHintText) == 0x000018, "Wrong size on MultiLineEditableTextBox_SetHintText");
static_assert(offsetof(MultiLineEditableTextBox_SetHintText, InHintText) == 0x000000, "Member 'MultiLineEditableTextBox_SetHintText::InHintText' has a wrong offset!");

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

// Function UMG.MultiLineEditableTextBox.SetText
// 0x0018 (0x0018 - 0x0000)
struct MultiLineEditableTextBox_SetText final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(MultiLineEditableTextBox_SetText) == 0x000008, "Wrong alignment on MultiLineEditableTextBox_SetText");
static_assert(sizeof(MultiLineEditableTextBox_SetText) == 0x000018, "Wrong size on MultiLineEditableTextBox_SetText");
static_assert(offsetof(MultiLineEditableTextBox_SetText, InText) == 0x000000, "Member 'MultiLineEditableTextBox_SetText::InText' has a wrong offset!");

// Function UMG.MultiLineEditableTextBox.SetTextStyle
// 0x0270 (0x0270 - 0x0000)
struct MultiLineEditableTextBox_SetTextStyle final
{
public:
	struct FTextBlockStyle                        InTextStyle;                                       // 0x0000(0x0270)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(MultiLineEditableTextBox_SetTextStyle) == 0x000008, "Wrong alignment on MultiLineEditableTextBox_SetTextStyle");
static_assert(sizeof(MultiLineEditableTextBox_SetTextStyle) == 0x000270, "Wrong size on MultiLineEditableTextBox_SetTextStyle");
static_assert(offsetof(MultiLineEditableTextBox_SetTextStyle, InTextStyle) == 0x000000, "Member 'MultiLineEditableTextBox_SetTextStyle::InTextStyle' has a wrong offset!");

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

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

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

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

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

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

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

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

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

// Function UMG.RetainerBox.SetEffectMaterial
// 0x0008 (0x0008 - 0x0000)
struct RetainerBox_SetEffectMaterial final
{
public:
	class UMaterialInterface*                     EffectMaterial_0;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RetainerBox_SetEffectMaterial) == 0x000008, "Wrong alignment on RetainerBox_SetEffectMaterial");
static_assert(sizeof(RetainerBox_SetEffectMaterial) == 0x000008, "Wrong size on RetainerBox_SetEffectMaterial");
static_assert(offsetof(RetainerBox_SetEffectMaterial, EffectMaterial_0) == 0x000000, "Member 'RetainerBox_SetEffectMaterial::EffectMaterial_0' has a wrong offset!");

// Function UMG.RetainerBox.SetRenderingPhase
// 0x0008 (0x0008 - 0x0000)
struct RetainerBox_SetRenderingPhase final
{
public:
	int32                                         RenderPhase;                                       // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         TotalPhases;                                       // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(RetainerBox_SetRenderingPhase) == 0x000004, "Wrong alignment on RetainerBox_SetRenderingPhase");
static_assert(sizeof(RetainerBox_SetRenderingPhase) == 0x000008, "Wrong size on RetainerBox_SetRenderingPhase");
static_assert(offsetof(RetainerBox_SetRenderingPhase, RenderPhase) == 0x000000, "Member 'RetainerBox_SetRenderingPhase::RenderPhase' has a wrong offset!");
static_assert(offsetof(RetainerBox_SetRenderingPhase, TotalPhases) == 0x000004, "Member 'RetainerBox_SetRenderingPhase::TotalPhases' has a wrong offset!");

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

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

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

// Function UMG.SafeZone.SetSidesToPad
// 0x0004 (0x0004 - 0x0000)
struct SafeZone_SetSidesToPad final
{
public:
	bool                                          InPadLeft;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          InPadRight;                                        // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          InPadTop;                                          // 0x0002(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          InPadBottom;                                       // 0x0003(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SafeZone_SetSidesToPad) == 0x000001, "Wrong alignment on SafeZone_SetSidesToPad");
static_assert(sizeof(SafeZone_SetSidesToPad) == 0x000004, "Wrong size on SafeZone_SetSidesToPad");
static_assert(offsetof(SafeZone_SetSidesToPad, InPadLeft) == 0x000000, "Member 'SafeZone_SetSidesToPad::InPadLeft' has a wrong offset!");
static_assert(offsetof(SafeZone_SetSidesToPad, InPadRight) == 0x000001, "Member 'SafeZone_SetSidesToPad::InPadRight' has a wrong offset!");
static_assert(offsetof(SafeZone_SetSidesToPad, InPadTop) == 0x000002, "Member 'SafeZone_SetSidesToPad::InPadTop' has a wrong offset!");
static_assert(offsetof(SafeZone_SetSidesToPad, InPadBottom) == 0x000003, "Member 'SafeZone_SetSidesToPad::InPadBottom' has a wrong offset!");

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

// Function UMG.ScaleBox.SetStretch
// 0x0001 (0x0001 - 0x0000)
struct ScaleBox_SetStretch final
{
public:
	EStretch                                      InStretch;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScaleBox_SetStretch) == 0x000001, "Wrong alignment on ScaleBox_SetStretch");
static_assert(sizeof(ScaleBox_SetStretch) == 0x000001, "Wrong size on ScaleBox_SetStretch");
static_assert(offsetof(ScaleBox_SetStretch, InStretch) == 0x000000, "Member 'ScaleBox_SetStretch::InStretch' has a wrong offset!");

// Function UMG.ScaleBox.SetStretchDirection
// 0x0001 (0x0001 - 0x0000)
struct ScaleBox_SetStretchDirection final
{
public:
	EStretchDirection                             InStretchDirection;                                // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScaleBox_SetStretchDirection) == 0x000001, "Wrong alignment on ScaleBox_SetStretchDirection");
static_assert(sizeof(ScaleBox_SetStretchDirection) == 0x000001, "Wrong size on ScaleBox_SetStretchDirection");
static_assert(offsetof(ScaleBox_SetStretchDirection, InStretchDirection) == 0x000000, "Member 'ScaleBox_SetStretchDirection::InStretchDirection' has a wrong offset!");

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

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

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

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

// Function UMG.ScrollBar.SetState
// 0x0008 (0x0008 - 0x0000)
struct ScrollBar_SetState final
{
public:
	float                                         InOffsetFraction;                                  // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InThumbSizeFraction;                               // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScrollBar_SetState) == 0x000004, "Wrong alignment on ScrollBar_SetState");
static_assert(sizeof(ScrollBar_SetState) == 0x000008, "Wrong size on ScrollBar_SetState");
static_assert(offsetof(ScrollBar_SetState, InOffsetFraction) == 0x000000, "Member 'ScrollBar_SetState::InOffsetFraction' has a wrong offset!");
static_assert(offsetof(ScrollBar_SetState, InThumbSizeFraction) == 0x000004, "Member 'ScrollBar_SetState::InThumbSizeFraction' has a wrong offset!");

// Function UMG.ScrollBox.ScrollWidgetIntoView
// 0x0010 (0x0010 - 0x0000)
struct ScrollBox_ScrollWidgetIntoView final
{
public:
	class UWidget*                                WidgetToFind;                                      // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          AnimateScroll;                                     // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDescendantScrollDestination                  ScrollDestination;                                 // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x2];                                        // 0x000A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Padding;                                           // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScrollBox_ScrollWidgetIntoView) == 0x000008, "Wrong alignment on ScrollBox_ScrollWidgetIntoView");
static_assert(sizeof(ScrollBox_ScrollWidgetIntoView) == 0x000010, "Wrong size on ScrollBox_ScrollWidgetIntoView");
static_assert(offsetof(ScrollBox_ScrollWidgetIntoView, WidgetToFind) == 0x000000, "Member 'ScrollBox_ScrollWidgetIntoView::WidgetToFind' has a wrong offset!");
static_assert(offsetof(ScrollBox_ScrollWidgetIntoView, AnimateScroll) == 0x000008, "Member 'ScrollBox_ScrollWidgetIntoView::AnimateScroll' has a wrong offset!");
static_assert(offsetof(ScrollBox_ScrollWidgetIntoView, ScrollDestination) == 0x000009, "Member 'ScrollBox_ScrollWidgetIntoView::ScrollDestination' has a wrong offset!");
static_assert(offsetof(ScrollBox_ScrollWidgetIntoView, Padding) == 0x00000C, "Member 'ScrollBox_ScrollWidgetIntoView::Padding' has a wrong offset!");

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

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

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

// Function UMG.ScrollBox.SetConsumeMouseWheel
// 0x0001 (0x0001 - 0x0000)
struct ScrollBox_SetConsumeMouseWheel final
{
public:
	EConsumeMouseWheel                            NewConsumeMouseWheel;                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScrollBox_SetConsumeMouseWheel) == 0x000001, "Wrong alignment on ScrollBox_SetConsumeMouseWheel");
static_assert(sizeof(ScrollBox_SetConsumeMouseWheel) == 0x000001, "Wrong size on ScrollBox_SetConsumeMouseWheel");
static_assert(offsetof(ScrollBox_SetConsumeMouseWheel, NewConsumeMouseWheel) == 0x000000, "Member 'ScrollBox_SetConsumeMouseWheel::NewConsumeMouseWheel' has a wrong offset!");

// Function UMG.ScrollBox.SetOrientation
// 0x0001 (0x0001 - 0x0000)
struct ScrollBox_SetOrientation final
{
public:
	EOrientation                                  NewOrientation;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScrollBox_SetOrientation) == 0x000001, "Wrong alignment on ScrollBox_SetOrientation");
static_assert(sizeof(ScrollBox_SetOrientation) == 0x000001, "Wrong size on ScrollBox_SetOrientation");
static_assert(offsetof(ScrollBox_SetOrientation, NewOrientation) == 0x000000, "Member 'ScrollBox_SetOrientation::NewOrientation' has a wrong offset!");

// Function UMG.ScrollBox.SetScrollbarPadding
// 0x0010 (0x0010 - 0x0000)
struct ScrollBox_SetScrollbarPadding final
{
public:
	struct FMargin                                NewScrollbarPadding;                               // 0x0000(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScrollBox_SetScrollbarPadding) == 0x000004, "Wrong alignment on ScrollBox_SetScrollbarPadding");
static_assert(sizeof(ScrollBox_SetScrollbarPadding) == 0x000010, "Wrong size on ScrollBox_SetScrollbarPadding");
static_assert(offsetof(ScrollBox_SetScrollbarPadding, NewScrollbarPadding) == 0x000000, "Member 'ScrollBox_SetScrollbarPadding::NewScrollbarPadding' has a wrong offset!");

// Function UMG.ScrollBox.SetScrollbarThickness
// 0x0008 (0x0008 - 0x0000)
struct ScrollBox_SetScrollbarThickness final
{
public:
	struct FVector2D                              NewScrollbarThickness;                             // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScrollBox_SetScrollbarThickness) == 0x000004, "Wrong alignment on ScrollBox_SetScrollbarThickness");
static_assert(sizeof(ScrollBox_SetScrollbarThickness) == 0x000008, "Wrong size on ScrollBox_SetScrollbarThickness");
static_assert(offsetof(ScrollBox_SetScrollbarThickness, NewScrollbarThickness) == 0x000000, "Member 'ScrollBox_SetScrollbarThickness::NewScrollbarThickness' has a wrong offset!");

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

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

// Function UMG.ScrollBox.SetScrollWhenFocusChanges
// 0x0001 (0x0001 - 0x0000)
struct ScrollBox_SetScrollWhenFocusChanges final
{
public:
	EScrollWhenFocusChanges                       NewScrollWhenFocusChanges;                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(ScrollBox_SetScrollWhenFocusChanges) == 0x000001, "Wrong alignment on ScrollBox_SetScrollWhenFocusChanges");
static_assert(sizeof(ScrollBox_SetScrollWhenFocusChanges) == 0x000001, "Wrong size on ScrollBox_SetScrollWhenFocusChanges");
static_assert(offsetof(ScrollBox_SetScrollWhenFocusChanges, NewScrollWhenFocusChanges) == 0x000000, "Member 'ScrollBox_SetScrollWhenFocusChanges::NewScrollWhenFocusChanges' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.SlateBlueprintLibrary.AbsoluteToLocal
// 0x0048 (0x0048 - 0x0000)
struct SlateBlueprintLibrary_AbsoluteToLocal final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              AbsoluteCoordinate;                                // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              ReturnValue;                                       // 0x0040(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_AbsoluteToLocal) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_AbsoluteToLocal");
static_assert(sizeof(SlateBlueprintLibrary_AbsoluteToLocal) == 0x000048, "Wrong size on SlateBlueprintLibrary_AbsoluteToLocal");
static_assert(offsetof(SlateBlueprintLibrary_AbsoluteToLocal, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_AbsoluteToLocal::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_AbsoluteToLocal, AbsoluteCoordinate) == 0x000038, "Member 'SlateBlueprintLibrary_AbsoluteToLocal::AbsoluteCoordinate' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_AbsoluteToLocal, ReturnValue) == 0x000040, "Member 'SlateBlueprintLibrary_AbsoluteToLocal::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.AbsoluteToViewport
// 0x0020 (0x0020 - 0x0000)
struct SlateBlueprintLibrary_AbsoluteToViewport final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              AbsoluteDesktopCoordinate;                         // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              PixelPosition;                                     // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              ViewportPosition;                                  // 0x0018(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_AbsoluteToViewport) == 0x000008, "Wrong alignment on SlateBlueprintLibrary_AbsoluteToViewport");
static_assert(sizeof(SlateBlueprintLibrary_AbsoluteToViewport) == 0x000020, "Wrong size on SlateBlueprintLibrary_AbsoluteToViewport");
static_assert(offsetof(SlateBlueprintLibrary_AbsoluteToViewport, WorldContextObject) == 0x000000, "Member 'SlateBlueprintLibrary_AbsoluteToViewport::WorldContextObject' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_AbsoluteToViewport, AbsoluteDesktopCoordinate) == 0x000008, "Member 'SlateBlueprintLibrary_AbsoluteToViewport::AbsoluteDesktopCoordinate' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_AbsoluteToViewport, PixelPosition) == 0x000010, "Member 'SlateBlueprintLibrary_AbsoluteToViewport::PixelPosition' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_AbsoluteToViewport, ViewportPosition) == 0x000018, "Member 'SlateBlueprintLibrary_AbsoluteToViewport::ViewportPosition' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.EqualEqual_SlateBrush
// 0x0118 (0x0118 - 0x0000)
struct SlateBlueprintLibrary_EqualEqual_SlateBrush final
{
public:
	struct FSlateBrush                            A;                                                 // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FSlateBrush                            B;                                                 // 0x0088(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0110(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_111[0x7];                                      // 0x0111(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(SlateBlueprintLibrary_EqualEqual_SlateBrush) == 0x000008, "Wrong alignment on SlateBlueprintLibrary_EqualEqual_SlateBrush");
static_assert(sizeof(SlateBlueprintLibrary_EqualEqual_SlateBrush) == 0x000118, "Wrong size on SlateBlueprintLibrary_EqualEqual_SlateBrush");
static_assert(offsetof(SlateBlueprintLibrary_EqualEqual_SlateBrush, A) == 0x000000, "Member 'SlateBlueprintLibrary_EqualEqual_SlateBrush::A' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_EqualEqual_SlateBrush, B) == 0x000088, "Member 'SlateBlueprintLibrary_EqualEqual_SlateBrush::B' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_EqualEqual_SlateBrush, ReturnValue) == 0x000110, "Member 'SlateBlueprintLibrary_EqualEqual_SlateBrush::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.GetAbsoluteSize
// 0x0040 (0x0040 - 0x0000)
struct SlateBlueprintLibrary_GetAbsoluteSize final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              ReturnValue;                                       // 0x0038(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_GetAbsoluteSize) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_GetAbsoluteSize");
static_assert(sizeof(SlateBlueprintLibrary_GetAbsoluteSize) == 0x000040, "Wrong size on SlateBlueprintLibrary_GetAbsoluteSize");
static_assert(offsetof(SlateBlueprintLibrary_GetAbsoluteSize, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_GetAbsoluteSize::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_GetAbsoluteSize, ReturnValue) == 0x000038, "Member 'SlateBlueprintLibrary_GetAbsoluteSize::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.GetLocalSize
// 0x0040 (0x0040 - 0x0000)
struct SlateBlueprintLibrary_GetLocalSize final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              ReturnValue;                                       // 0x0038(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_GetLocalSize) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_GetLocalSize");
static_assert(sizeof(SlateBlueprintLibrary_GetLocalSize) == 0x000040, "Wrong size on SlateBlueprintLibrary_GetLocalSize");
static_assert(offsetof(SlateBlueprintLibrary_GetLocalSize, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_GetLocalSize::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_GetLocalSize, ReturnValue) == 0x000038, "Member 'SlateBlueprintLibrary_GetLocalSize::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.GetLocalTopLeft
// 0x0040 (0x0040 - 0x0000)
struct SlateBlueprintLibrary_GetLocalTopLeft final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              ReturnValue;                                       // 0x0038(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_GetLocalTopLeft) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_GetLocalTopLeft");
static_assert(sizeof(SlateBlueprintLibrary_GetLocalTopLeft) == 0x000040, "Wrong size on SlateBlueprintLibrary_GetLocalTopLeft");
static_assert(offsetof(SlateBlueprintLibrary_GetLocalTopLeft, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_GetLocalTopLeft::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_GetLocalTopLeft, ReturnValue) == 0x000038, "Member 'SlateBlueprintLibrary_GetLocalTopLeft::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.IsUnderLocation
// 0x0044 (0x0044 - 0x0000)
struct SlateBlueprintLibrary_IsUnderLocation final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              AbsoluteCoordinate;                                // 0x0038(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0040(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_41[0x3];                                       // 0x0041(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(SlateBlueprintLibrary_IsUnderLocation) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_IsUnderLocation");
static_assert(sizeof(SlateBlueprintLibrary_IsUnderLocation) == 0x000044, "Wrong size on SlateBlueprintLibrary_IsUnderLocation");
static_assert(offsetof(SlateBlueprintLibrary_IsUnderLocation, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_IsUnderLocation::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_IsUnderLocation, AbsoluteCoordinate) == 0x000038, "Member 'SlateBlueprintLibrary_IsUnderLocation::AbsoluteCoordinate' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_IsUnderLocation, ReturnValue) == 0x000040, "Member 'SlateBlueprintLibrary_IsUnderLocation::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.LocalToAbsolute
// 0x0048 (0x0048 - 0x0000)
struct SlateBlueprintLibrary_LocalToAbsolute final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              LocalCoordinate;                                   // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              ReturnValue;                                       // 0x0040(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_LocalToAbsolute) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_LocalToAbsolute");
static_assert(sizeof(SlateBlueprintLibrary_LocalToAbsolute) == 0x000048, "Wrong size on SlateBlueprintLibrary_LocalToAbsolute");
static_assert(offsetof(SlateBlueprintLibrary_LocalToAbsolute, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_LocalToAbsolute::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_LocalToAbsolute, LocalCoordinate) == 0x000038, "Member 'SlateBlueprintLibrary_LocalToAbsolute::LocalCoordinate' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_LocalToAbsolute, ReturnValue) == 0x000040, "Member 'SlateBlueprintLibrary_LocalToAbsolute::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.LocalToViewport
// 0x0058 (0x0058 - 0x0000)
struct SlateBlueprintLibrary_LocalToViewport final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGeometry                              Geometry;                                          // 0x0008(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              LocalCoordinate;                                   // 0x0040(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              PixelPosition;                                     // 0x0048(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              ViewportPosition;                                  // 0x0050(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_LocalToViewport) == 0x000008, "Wrong alignment on SlateBlueprintLibrary_LocalToViewport");
static_assert(sizeof(SlateBlueprintLibrary_LocalToViewport) == 0x000058, "Wrong size on SlateBlueprintLibrary_LocalToViewport");
static_assert(offsetof(SlateBlueprintLibrary_LocalToViewport, WorldContextObject) == 0x000000, "Member 'SlateBlueprintLibrary_LocalToViewport::WorldContextObject' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_LocalToViewport, Geometry) == 0x000008, "Member 'SlateBlueprintLibrary_LocalToViewport::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_LocalToViewport, LocalCoordinate) == 0x000040, "Member 'SlateBlueprintLibrary_LocalToViewport::LocalCoordinate' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_LocalToViewport, PixelPosition) == 0x000048, "Member 'SlateBlueprintLibrary_LocalToViewport::PixelPosition' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_LocalToViewport, ViewportPosition) == 0x000050, "Member 'SlateBlueprintLibrary_LocalToViewport::ViewportPosition' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.ScreenToViewport
// 0x0018 (0x0018 - 0x0000)
struct SlateBlueprintLibrary_ScreenToViewport final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              ScreenPosition;                                    // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              ViewportPosition;                                  // 0x0010(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_ScreenToViewport) == 0x000008, "Wrong alignment on SlateBlueprintLibrary_ScreenToViewport");
static_assert(sizeof(SlateBlueprintLibrary_ScreenToViewport) == 0x000018, "Wrong size on SlateBlueprintLibrary_ScreenToViewport");
static_assert(offsetof(SlateBlueprintLibrary_ScreenToViewport, WorldContextObject) == 0x000000, "Member 'SlateBlueprintLibrary_ScreenToViewport::WorldContextObject' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_ScreenToViewport, ScreenPosition) == 0x000008, "Member 'SlateBlueprintLibrary_ScreenToViewport::ScreenPosition' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_ScreenToViewport, ViewportPosition) == 0x000010, "Member 'SlateBlueprintLibrary_ScreenToViewport::ViewportPosition' has a wrong offset!");

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

// Function UMG.SlateBlueprintLibrary.ScreenToWidgetLocal
// 0x0058 (0x0058 - 0x0000)
struct SlateBlueprintLibrary_ScreenToWidgetLocal final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGeometry                              Geometry;                                          // 0x0008(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              ScreenPosition;                                    // 0x0040(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              LocalCoordinate;                                   // 0x0048(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIncludeWindowPosition;                            // 0x0050(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_51[0x7];                                       // 0x0051(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(SlateBlueprintLibrary_ScreenToWidgetLocal) == 0x000008, "Wrong alignment on SlateBlueprintLibrary_ScreenToWidgetLocal");
static_assert(sizeof(SlateBlueprintLibrary_ScreenToWidgetLocal) == 0x000058, "Wrong size on SlateBlueprintLibrary_ScreenToWidgetLocal");
static_assert(offsetof(SlateBlueprintLibrary_ScreenToWidgetLocal, WorldContextObject) == 0x000000, "Member 'SlateBlueprintLibrary_ScreenToWidgetLocal::WorldContextObject' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_ScreenToWidgetLocal, Geometry) == 0x000008, "Member 'SlateBlueprintLibrary_ScreenToWidgetLocal::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_ScreenToWidgetLocal, ScreenPosition) == 0x000040, "Member 'SlateBlueprintLibrary_ScreenToWidgetLocal::ScreenPosition' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_ScreenToWidgetLocal, LocalCoordinate) == 0x000048, "Member 'SlateBlueprintLibrary_ScreenToWidgetLocal::LocalCoordinate' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_ScreenToWidgetLocal, bIncludeWindowPosition) == 0x000050, "Member 'SlateBlueprintLibrary_ScreenToWidgetLocal::bIncludeWindowPosition' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.TransformScalarAbsoluteToLocal
// 0x0040 (0x0040 - 0x0000)
struct SlateBlueprintLibrary_TransformScalarAbsoluteToLocal final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         AbsoluteScalar;                                    // 0x0038(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x003C(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_TransformScalarAbsoluteToLocal) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_TransformScalarAbsoluteToLocal");
static_assert(sizeof(SlateBlueprintLibrary_TransformScalarAbsoluteToLocal) == 0x000040, "Wrong size on SlateBlueprintLibrary_TransformScalarAbsoluteToLocal");
static_assert(offsetof(SlateBlueprintLibrary_TransformScalarAbsoluteToLocal, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_TransformScalarAbsoluteToLocal::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_TransformScalarAbsoluteToLocal, AbsoluteScalar) == 0x000038, "Member 'SlateBlueprintLibrary_TransformScalarAbsoluteToLocal::AbsoluteScalar' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_TransformScalarAbsoluteToLocal, ReturnValue) == 0x00003C, "Member 'SlateBlueprintLibrary_TransformScalarAbsoluteToLocal::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.TransformScalarLocalToAbsolute
// 0x0040 (0x0040 - 0x0000)
struct SlateBlueprintLibrary_TransformScalarLocalToAbsolute final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         LocalScalar;                                       // 0x0038(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x003C(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_TransformScalarLocalToAbsolute) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_TransformScalarLocalToAbsolute");
static_assert(sizeof(SlateBlueprintLibrary_TransformScalarLocalToAbsolute) == 0x000040, "Wrong size on SlateBlueprintLibrary_TransformScalarLocalToAbsolute");
static_assert(offsetof(SlateBlueprintLibrary_TransformScalarLocalToAbsolute, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_TransformScalarLocalToAbsolute::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_TransformScalarLocalToAbsolute, LocalScalar) == 0x000038, "Member 'SlateBlueprintLibrary_TransformScalarLocalToAbsolute::LocalScalar' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_TransformScalarLocalToAbsolute, ReturnValue) == 0x00003C, "Member 'SlateBlueprintLibrary_TransformScalarLocalToAbsolute::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.TransformVectorAbsoluteToLocal
// 0x0048 (0x0048 - 0x0000)
struct SlateBlueprintLibrary_TransformVectorAbsoluteToLocal final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              AbsoluteVector;                                    // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              ReturnValue;                                       // 0x0040(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_TransformVectorAbsoluteToLocal) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_TransformVectorAbsoluteToLocal");
static_assert(sizeof(SlateBlueprintLibrary_TransformVectorAbsoluteToLocal) == 0x000048, "Wrong size on SlateBlueprintLibrary_TransformVectorAbsoluteToLocal");
static_assert(offsetof(SlateBlueprintLibrary_TransformVectorAbsoluteToLocal, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_TransformVectorAbsoluteToLocal::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_TransformVectorAbsoluteToLocal, AbsoluteVector) == 0x000038, "Member 'SlateBlueprintLibrary_TransformVectorAbsoluteToLocal::AbsoluteVector' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_TransformVectorAbsoluteToLocal, ReturnValue) == 0x000040, "Member 'SlateBlueprintLibrary_TransformVectorAbsoluteToLocal::ReturnValue' has a wrong offset!");

// Function UMG.SlateBlueprintLibrary.TransformVectorLocalToAbsolute
// 0x0048 (0x0048 - 0x0000)
struct SlateBlueprintLibrary_TransformVectorLocalToAbsolute final
{
public:
	struct FGeometry                              Geometry;                                          // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              LocalVector;                                       // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              ReturnValue;                                       // 0x0040(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(SlateBlueprintLibrary_TransformVectorLocalToAbsolute) == 0x000004, "Wrong alignment on SlateBlueprintLibrary_TransformVectorLocalToAbsolute");
static_assert(sizeof(SlateBlueprintLibrary_TransformVectorLocalToAbsolute) == 0x000048, "Wrong size on SlateBlueprintLibrary_TransformVectorLocalToAbsolute");
static_assert(offsetof(SlateBlueprintLibrary_TransformVectorLocalToAbsolute, Geometry) == 0x000000, "Member 'SlateBlueprintLibrary_TransformVectorLocalToAbsolute::Geometry' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_TransformVectorLocalToAbsolute, LocalVector) == 0x000038, "Member 'SlateBlueprintLibrary_TransformVectorLocalToAbsolute::LocalVector' has a wrong offset!");
static_assert(offsetof(SlateBlueprintLibrary_TransformVectorLocalToAbsolute, ReturnValue) == 0x000040, "Member 'SlateBlueprintLibrary_TransformVectorLocalToAbsolute::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.SpinBox.SetForegroundColor
// 0x0028 (0x0028 - 0x0000)
struct SpinBox_SetForegroundColor final
{
public:
	struct FSlateColor                            InForegroundColor;                                 // 0x0000(0x0028)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(SpinBox_SetForegroundColor) == 0x000008, "Wrong alignment on SpinBox_SetForegroundColor");
static_assert(sizeof(SpinBox_SetForegroundColor) == 0x000028, "Wrong size on SpinBox_SetForegroundColor");
static_assert(offsetof(SpinBox_SetForegroundColor, InForegroundColor) == 0x000000, "Member 'SpinBox_SetForegroundColor::InForegroundColor' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.TextBlock.SetColorAndOpacity
// 0x0028 (0x0028 - 0x0000)
struct TextBlock_SetColorAndOpacity final
{
public:
	struct FSlateColor                            InColorAndOpacity;                                 // 0x0000(0x0028)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(TextBlock_SetColorAndOpacity) == 0x000008, "Wrong alignment on TextBlock_SetColorAndOpacity");
static_assert(sizeof(TextBlock_SetColorAndOpacity) == 0x000028, "Wrong size on TextBlock_SetColorAndOpacity");
static_assert(offsetof(TextBlock_SetColorAndOpacity, InColorAndOpacity) == 0x000000, "Member 'TextBlock_SetColorAndOpacity::InColorAndOpacity' has a wrong offset!");

// Function UMG.TextBlock.SetFont
// 0x0058 (0x0058 - 0x0000)
struct TextBlock_SetFont final
{
public:
	struct FSlateFontInfo                         InFontInfo;                                        // 0x0000(0x0058)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TextBlock_SetFont) == 0x000008, "Wrong alignment on TextBlock_SetFont");
static_assert(sizeof(TextBlock_SetFont) == 0x000058, "Wrong size on TextBlock_SetFont");
static_assert(offsetof(TextBlock_SetFont, InFontInfo) == 0x000000, "Member 'TextBlock_SetFont::InFontInfo' has a wrong offset!");

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

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

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

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

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

// Function UMG.TextBlock.SetText
// 0x0018 (0x0018 - 0x0000)
struct TextBlock_SetText final
{
public:
	class FText                                   InText;                                            // 0x0000(0x0018)(Parm, NativeAccessSpecifierPublic)
};
static_assert(alignof(TextBlock_SetText) == 0x000008, "Wrong alignment on TextBlock_SetText");
static_assert(sizeof(TextBlock_SetText) == 0x000018, "Wrong size on TextBlock_SetText");
static_assert(offsetof(TextBlock_SetText, InText) == 0x000000, "Member 'TextBlock_SetText::InText' has a wrong offset!");

// Function UMG.TextBlock.SetTextTransformPolicy
// 0x0001 (0x0001 - 0x0000)
struct TextBlock_SetTextTransformPolicy final
{
public:
	ETextTransformPolicy                          InTransformPolicy;                                 // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TextBlock_SetTextTransformPolicy) == 0x000001, "Wrong alignment on TextBlock_SetTextTransformPolicy");
static_assert(sizeof(TextBlock_SetTextTransformPolicy) == 0x000001, "Wrong size on TextBlock_SetTextTransformPolicy");
static_assert(offsetof(TextBlock_SetTextTransformPolicy, InTransformPolicy) == 0x000000, "Member 'TextBlock_SetTextTransformPolicy::InTransformPolicy' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.UniformGridPanel.AddChildToUniformGrid
// 0x0018 (0x0018 - 0x0000)
struct UniformGridPanel_AddChildToUniformGrid final
{
public:
	class UWidget*                                Content;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InRow;                                             // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InColumn;                                          // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UUniformGridSlot*                       ReturnValue;                                       // 0x0010(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(UniformGridPanel_AddChildToUniformGrid) == 0x000008, "Wrong alignment on UniformGridPanel_AddChildToUniformGrid");
static_assert(sizeof(UniformGridPanel_AddChildToUniformGrid) == 0x000018, "Wrong size on UniformGridPanel_AddChildToUniformGrid");
static_assert(offsetof(UniformGridPanel_AddChildToUniformGrid, Content) == 0x000000, "Member 'UniformGridPanel_AddChildToUniformGrid::Content' has a wrong offset!");
static_assert(offsetof(UniformGridPanel_AddChildToUniformGrid, InRow) == 0x000008, "Member 'UniformGridPanel_AddChildToUniformGrid::InRow' has a wrong offset!");
static_assert(offsetof(UniformGridPanel_AddChildToUniformGrid, InColumn) == 0x00000C, "Member 'UniformGridPanel_AddChildToUniformGrid::InColumn' has a wrong offset!");
static_assert(offsetof(UniformGridPanel_AddChildToUniformGrid, ReturnValue) == 0x000010, "Member 'UniformGridPanel_AddChildToUniformGrid::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

// Function UMG.VerticalBoxSlot.SetSize
// 0x0008 (0x0008 - 0x0000)
struct VerticalBoxSlot_SetSize final
{
public:
	struct FSlateChildSize                        InSize;                                            // 0x0000(0x0008)(Parm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(VerticalBoxSlot_SetSize) == 0x000004, "Wrong alignment on VerticalBoxSlot_SetSize");
static_assert(sizeof(VerticalBoxSlot_SetSize) == 0x000008, "Wrong size on VerticalBoxSlot_SetSize");
static_assert(offsetof(VerticalBoxSlot_SetSize, InSize) == 0x000000, "Member 'VerticalBoxSlot_SetSize::InSize' has a wrong offset!");

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

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

// Function UMG.Viewport.SetViewRotation
// 0x000C (0x000C - 0x0000)
struct Viewport_SetViewRotation final
{
public:
	struct FRotator                               Rotation;                                          // 0x0000(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(Viewport_SetViewRotation) == 0x000004, "Wrong alignment on Viewport_SetViewRotation");
static_assert(sizeof(Viewport_SetViewRotation) == 0x00000C, "Wrong size on Viewport_SetViewRotation");
static_assert(offsetof(Viewport_SetViewRotation, Rotation) == 0x000000, "Member 'Viewport_SetViewRotation::Rotation' has a wrong offset!");

// Function UMG.Viewport.Spawn
// 0x0010 (0x0010 - 0x0000)
struct Viewport_Spawn final
{
public:
	TSubclassOf<class AActor>                     ActorClass;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(Viewport_Spawn) == 0x000008, "Wrong alignment on Viewport_Spawn");
static_assert(sizeof(Viewport_Spawn) == 0x000010, "Wrong size on Viewport_Spawn");
static_assert(offsetof(Viewport_Spawn, ActorClass) == 0x000000, "Member 'Viewport_Spawn::ActorClass' has a wrong offset!");
static_assert(offsetof(Viewport_Spawn, ReturnValue) == 0x000008, "Member 'Viewport_Spawn::ReturnValue' has a wrong offset!");

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

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

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

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

// Function UMG.WidgetAnimation.BindToAnimationFinished
// 0x0018 (0x0018 - 0x0000)
struct WidgetAnimation_BindToAnimationFinished final
{
public:
	class UUserWidget*                            Widget;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             Delegate;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetAnimation_BindToAnimationFinished) == 0x000008, "Wrong alignment on WidgetAnimation_BindToAnimationFinished");
static_assert(sizeof(WidgetAnimation_BindToAnimationFinished) == 0x000018, "Wrong size on WidgetAnimation_BindToAnimationFinished");
static_assert(offsetof(WidgetAnimation_BindToAnimationFinished, Widget) == 0x000000, "Member 'WidgetAnimation_BindToAnimationFinished::Widget' has a wrong offset!");
static_assert(offsetof(WidgetAnimation_BindToAnimationFinished, Delegate) == 0x000008, "Member 'WidgetAnimation_BindToAnimationFinished::Delegate' has a wrong offset!");

// Function UMG.WidgetAnimation.BindToAnimationStarted
// 0x0018 (0x0018 - 0x0000)
struct WidgetAnimation_BindToAnimationStarted final
{
public:
	class UUserWidget*                            Widget;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             Delegate;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetAnimation_BindToAnimationStarted) == 0x000008, "Wrong alignment on WidgetAnimation_BindToAnimationStarted");
static_assert(sizeof(WidgetAnimation_BindToAnimationStarted) == 0x000018, "Wrong size on WidgetAnimation_BindToAnimationStarted");
static_assert(offsetof(WidgetAnimation_BindToAnimationStarted, Widget) == 0x000000, "Member 'WidgetAnimation_BindToAnimationStarted::Widget' has a wrong offset!");
static_assert(offsetof(WidgetAnimation_BindToAnimationStarted, Delegate) == 0x000008, "Member 'WidgetAnimation_BindToAnimationStarted::Delegate' has a wrong offset!");

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

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

// Function UMG.WidgetAnimation.UnbindFromAnimationFinished
// 0x0018 (0x0018 - 0x0000)
struct WidgetAnimation_UnbindFromAnimationFinished final
{
public:
	class UUserWidget*                            Widget;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             Delegate;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetAnimation_UnbindFromAnimationFinished) == 0x000008, "Wrong alignment on WidgetAnimation_UnbindFromAnimationFinished");
static_assert(sizeof(WidgetAnimation_UnbindFromAnimationFinished) == 0x000018, "Wrong size on WidgetAnimation_UnbindFromAnimationFinished");
static_assert(offsetof(WidgetAnimation_UnbindFromAnimationFinished, Widget) == 0x000000, "Member 'WidgetAnimation_UnbindFromAnimationFinished::Widget' has a wrong offset!");
static_assert(offsetof(WidgetAnimation_UnbindFromAnimationFinished, Delegate) == 0x000008, "Member 'WidgetAnimation_UnbindFromAnimationFinished::Delegate' has a wrong offset!");

// Function UMG.WidgetAnimation.UnbindFromAnimationStarted
// 0x0018 (0x0018 - 0x0000)
struct WidgetAnimation_UnbindFromAnimationStarted final
{
public:
	class UUserWidget*                            Widget;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             Delegate;                                          // 0x0008(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetAnimation_UnbindFromAnimationStarted) == 0x000008, "Wrong alignment on WidgetAnimation_UnbindFromAnimationStarted");
static_assert(sizeof(WidgetAnimation_UnbindFromAnimationStarted) == 0x000018, "Wrong size on WidgetAnimation_UnbindFromAnimationStarted");
static_assert(offsetof(WidgetAnimation_UnbindFromAnimationStarted, Widget) == 0x000000, "Member 'WidgetAnimation_UnbindFromAnimationStarted::Widget' has a wrong offset!");
static_assert(offsetof(WidgetAnimation_UnbindFromAnimationStarted, Delegate) == 0x000008, "Member 'WidgetAnimation_UnbindFromAnimationStarted::Delegate' has a wrong offset!");

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

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

// Function UMG.WidgetAnimationPlayCallbackProxy.CreatePlayAnimationProxyObject
// 0x0030 (0x0030 - 0x0000)
struct WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject final
{
public:
	class UUMGSequencePlayer*                     Result;                                            // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UUserWidget*                            Widget;                                            // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidgetAnimation*                       InAnimation;                                       // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StartAtTime;                                       // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumLoopsToPlay;                                    // 0x001C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EUMGSequencePlayMode                          PlayMode;                                          // 0x0020(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x3];                                       // 0x0021(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         PlaybackSpeed;                                     // 0x0024(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidgetAnimationPlayCallbackProxy*      ReturnValue;                                       // 0x0028(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject) == 0x000008, "Wrong alignment on WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject");
static_assert(sizeof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject) == 0x000030, "Wrong size on WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject, Result) == 0x000000, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject::Result' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject, Widget) == 0x000008, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject::Widget' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject, InAnimation) == 0x000010, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject::InAnimation' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject, StartAtTime) == 0x000018, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject::StartAtTime' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject, NumLoopsToPlay) == 0x00001C, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject::NumLoopsToPlay' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject, PlayMode) == 0x000020, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject::PlayMode' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject, PlaybackSpeed) == 0x000024, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject::PlaybackSpeed' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject, ReturnValue) == 0x000028, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationProxyObject::ReturnValue' has a wrong offset!");

// Function UMG.WidgetAnimationPlayCallbackProxy.CreatePlayAnimationTimeRangeProxyObject
// 0x0038 (0x0038 - 0x0000)
struct WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject final
{
public:
	class UUMGSequencePlayer*                     Result;                                            // 0x0000(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UUserWidget*                            Widget;                                            // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidgetAnimation*                       InAnimation;                                       // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StartAtTime;                                       // 0x0018(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         EndAtTime;                                         // 0x001C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumLoopsToPlay;                                    // 0x0020(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EUMGSequencePlayMode                          PlayMode;                                          // 0x0024(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_25[0x3];                                       // 0x0025(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         PlaybackSpeed;                                     // 0x0028(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UWidgetAnimationPlayCallbackProxy*      ReturnValue;                                       // 0x0030(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject) == 0x000008, "Wrong alignment on WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject");
static_assert(sizeof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject) == 0x000038, "Wrong size on WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject, Result) == 0x000000, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject::Result' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject, Widget) == 0x000008, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject::Widget' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject, InAnimation) == 0x000010, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject::InAnimation' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject, StartAtTime) == 0x000018, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject::StartAtTime' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject, EndAtTime) == 0x00001C, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject::EndAtTime' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject, NumLoopsToPlay) == 0x000020, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject::NumLoopsToPlay' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject, PlayMode) == 0x000024, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject::PlayMode' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject, PlaybackSpeed) == 0x000028, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject::PlaybackSpeed' has a wrong offset!");
static_assert(offsetof(WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject, ReturnValue) == 0x000030, "Member 'WidgetAnimationPlayCallbackProxy_CreatePlayAnimationTimeRangeProxyObject::ReturnValue' has a wrong offset!");

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

// Function UMG.WidgetBlueprintLibrary.CaptureJoystick
// 0x0180 (0x0180 - 0x0000)
struct WidgetBlueprintLibrary_CaptureJoystick final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UWidget*                                CapturingWidget;                                   // 0x00B8(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInAllJoysticks;                                   // 0x00C0(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FEventReply                            ReturnValue;                                       // 0x00C8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_CaptureJoystick) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_CaptureJoystick");
static_assert(sizeof(WidgetBlueprintLibrary_CaptureJoystick) == 0x000180, "Wrong size on WidgetBlueprintLibrary_CaptureJoystick");
static_assert(offsetof(WidgetBlueprintLibrary_CaptureJoystick, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_CaptureJoystick::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_CaptureJoystick, CapturingWidget) == 0x0000B8, "Member 'WidgetBlueprintLibrary_CaptureJoystick::CapturingWidget' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_CaptureJoystick, bInAllJoysticks) == 0x0000C0, "Member 'WidgetBlueprintLibrary_CaptureJoystick::bInAllJoysticks' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_CaptureJoystick, ReturnValue) == 0x0000C8, "Member 'WidgetBlueprintLibrary_CaptureJoystick::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.CaptureMouse
// 0x0178 (0x0178 - 0x0000)
struct WidgetBlueprintLibrary_CaptureMouse final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UWidget*                                CapturingWidget;                                   // 0x00B8(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00C0(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_CaptureMouse) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_CaptureMouse");
static_assert(sizeof(WidgetBlueprintLibrary_CaptureMouse) == 0x000178, "Wrong size on WidgetBlueprintLibrary_CaptureMouse");
static_assert(offsetof(WidgetBlueprintLibrary_CaptureMouse, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_CaptureMouse::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_CaptureMouse, CapturingWidget) == 0x0000B8, "Member 'WidgetBlueprintLibrary_CaptureMouse::CapturingWidget' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_CaptureMouse, ReturnValue) == 0x0000C0, "Member 'WidgetBlueprintLibrary_CaptureMouse::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.ClearUserFocus
// 0x0178 (0x0178 - 0x0000)
struct WidgetBlueprintLibrary_ClearUserFocus final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          bInAllUsers;                                       // 0x00B8(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B9[0x7];                                       // 0x00B9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FEventReply                            ReturnValue;                                       // 0x00C0(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_ClearUserFocus) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_ClearUserFocus");
static_assert(sizeof(WidgetBlueprintLibrary_ClearUserFocus) == 0x000178, "Wrong size on WidgetBlueprintLibrary_ClearUserFocus");
static_assert(offsetof(WidgetBlueprintLibrary_ClearUserFocus, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_ClearUserFocus::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_ClearUserFocus, bInAllUsers) == 0x0000B8, "Member 'WidgetBlueprintLibrary_ClearUserFocus::bInAllUsers' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_ClearUserFocus, ReturnValue) == 0x0000C0, "Member 'WidgetBlueprintLibrary_ClearUserFocus::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.Create
// 0x0020 (0x0020 - 0x0000)
struct WidgetBlueprintLibrary_Create final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UUserWidget>                WidgetType;                                        // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APlayerController*                      OwningPlayer;                                      // 0x0010(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UUserWidget*                            ReturnValue;                                       // 0x0018(0x0008)(ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_Create) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_Create");
static_assert(sizeof(WidgetBlueprintLibrary_Create) == 0x000020, "Wrong size on WidgetBlueprintLibrary_Create");
static_assert(offsetof(WidgetBlueprintLibrary_Create, WorldContextObject) == 0x000000, "Member 'WidgetBlueprintLibrary_Create::WorldContextObject' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_Create, WidgetType) == 0x000008, "Member 'WidgetBlueprintLibrary_Create::WidgetType' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_Create, OwningPlayer) == 0x000010, "Member 'WidgetBlueprintLibrary_Create::OwningPlayer' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_Create, ReturnValue) == 0x000018, "Member 'WidgetBlueprintLibrary_Create::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.CreateDragDropOperation
// 0x0010 (0x0010 - 0x0000)
struct WidgetBlueprintLibrary_CreateDragDropOperation final
{
public:
	TSubclassOf<class UDragDropOperation>         OperationClass;                                    // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UDragDropOperation*                     ReturnValue;                                       // 0x0008(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_CreateDragDropOperation) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_CreateDragDropOperation");
static_assert(sizeof(WidgetBlueprintLibrary_CreateDragDropOperation) == 0x000010, "Wrong size on WidgetBlueprintLibrary_CreateDragDropOperation");
static_assert(offsetof(WidgetBlueprintLibrary_CreateDragDropOperation, OperationClass) == 0x000000, "Member 'WidgetBlueprintLibrary_CreateDragDropOperation::OperationClass' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_CreateDragDropOperation, ReturnValue) == 0x000008, "Member 'WidgetBlueprintLibrary_CreateDragDropOperation::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.DetectDrag
// 0x0190 (0x0190 - 0x0000)
struct WidgetBlueprintLibrary_DetectDrag final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UWidget*                                WidgetDetectingDrag;                               // 0x00B8(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FKey                                   DragKey;                                           // 0x00C0(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00D8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_DetectDrag) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_DetectDrag");
static_assert(sizeof(WidgetBlueprintLibrary_DetectDrag) == 0x000190, "Wrong size on WidgetBlueprintLibrary_DetectDrag");
static_assert(offsetof(WidgetBlueprintLibrary_DetectDrag, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_DetectDrag::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DetectDrag, WidgetDetectingDrag) == 0x0000B8, "Member 'WidgetBlueprintLibrary_DetectDrag::WidgetDetectingDrag' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DetectDrag, DragKey) == 0x0000C0, "Member 'WidgetBlueprintLibrary_DetectDrag::DragKey' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DetectDrag, ReturnValue) == 0x0000D8, "Member 'WidgetBlueprintLibrary_DetectDrag::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.DetectDragIfPressed
// 0x0148 (0x0148 - 0x0000)
struct WidgetBlueprintLibrary_DetectDragIfPressed final
{
public:
	struct FPointerEvent                          PointerEvent;                                      // 0x0000(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UWidget*                                WidgetDetectingDrag;                               // 0x0070(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FKey                                   DragKey;                                           // 0x0078(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x0090(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_DetectDragIfPressed) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_DetectDragIfPressed");
static_assert(sizeof(WidgetBlueprintLibrary_DetectDragIfPressed) == 0x000148, "Wrong size on WidgetBlueprintLibrary_DetectDragIfPressed");
static_assert(offsetof(WidgetBlueprintLibrary_DetectDragIfPressed, PointerEvent) == 0x000000, "Member 'WidgetBlueprintLibrary_DetectDragIfPressed::PointerEvent' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DetectDragIfPressed, WidgetDetectingDrag) == 0x000070, "Member 'WidgetBlueprintLibrary_DetectDragIfPressed::WidgetDetectingDrag' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DetectDragIfPressed, DragKey) == 0x000078, "Member 'WidgetBlueprintLibrary_DetectDragIfPressed::DragKey' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DetectDragIfPressed, ReturnValue) == 0x000090, "Member 'WidgetBlueprintLibrary_DetectDragIfPressed::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.DrawBox
// 0x0058 (0x0058 - 0x0000)
struct WidgetBlueprintLibrary_DrawBox final
{
public:
	struct FPaintContext                          Context;                                           // 0x0000(0x0030)(Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              Position;                                          // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              Size;                                              // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       Brush;                                             // 0x0040(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           Tint;                                              // 0x0048(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_DrawBox) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_DrawBox");
static_assert(sizeof(WidgetBlueprintLibrary_DrawBox) == 0x000058, "Wrong size on WidgetBlueprintLibrary_DrawBox");
static_assert(offsetof(WidgetBlueprintLibrary_DrawBox, Context) == 0x000000, "Member 'WidgetBlueprintLibrary_DrawBox::Context' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawBox, Position) == 0x000030, "Member 'WidgetBlueprintLibrary_DrawBox::Position' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawBox, Size) == 0x000038, "Member 'WidgetBlueprintLibrary_DrawBox::Size' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawBox, Brush) == 0x000040, "Member 'WidgetBlueprintLibrary_DrawBox::Brush' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawBox, Tint) == 0x000048, "Member 'WidgetBlueprintLibrary_DrawBox::Tint' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.DrawLine
// 0x0058 (0x0058 - 0x0000)
struct WidgetBlueprintLibrary_DrawLine final
{
public:
	struct FPaintContext                          Context;                                           // 0x0000(0x0030)(Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              PositionA;                                         // 0x0030(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              PositionB;                                         // 0x0038(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           Tint;                                              // 0x0040(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAntiAlias;                                        // 0x0050(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_51[0x3];                                       // 0x0051(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Thickness;                                         // 0x0054(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_DrawLine) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_DrawLine");
static_assert(sizeof(WidgetBlueprintLibrary_DrawLine) == 0x000058, "Wrong size on WidgetBlueprintLibrary_DrawLine");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLine, Context) == 0x000000, "Member 'WidgetBlueprintLibrary_DrawLine::Context' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLine, PositionA) == 0x000030, "Member 'WidgetBlueprintLibrary_DrawLine::PositionA' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLine, PositionB) == 0x000038, "Member 'WidgetBlueprintLibrary_DrawLine::PositionB' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLine, Tint) == 0x000040, "Member 'WidgetBlueprintLibrary_DrawLine::Tint' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLine, bAntiAlias) == 0x000050, "Member 'WidgetBlueprintLibrary_DrawLine::bAntiAlias' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLine, Thickness) == 0x000054, "Member 'WidgetBlueprintLibrary_DrawLine::Thickness' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.DrawLines
// 0x0058 (0x0058 - 0x0000)
struct WidgetBlueprintLibrary_DrawLines final
{
public:
	struct FPaintContext                          Context;                                           // 0x0000(0x0030)(Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	TArray<struct FVector2D>                      Points;                                            // 0x0030(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
	struct FLinearColor                           Tint;                                              // 0x0040(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAntiAlias;                                        // 0x0050(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_51[0x3];                                       // 0x0051(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Thickness;                                         // 0x0054(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_DrawLines) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_DrawLines");
static_assert(sizeof(WidgetBlueprintLibrary_DrawLines) == 0x000058, "Wrong size on WidgetBlueprintLibrary_DrawLines");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLines, Context) == 0x000000, "Member 'WidgetBlueprintLibrary_DrawLines::Context' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLines, Points) == 0x000030, "Member 'WidgetBlueprintLibrary_DrawLines::Points' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLines, Tint) == 0x000040, "Member 'WidgetBlueprintLibrary_DrawLines::Tint' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLines, bAntiAlias) == 0x000050, "Member 'WidgetBlueprintLibrary_DrawLines::bAntiAlias' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawLines, Thickness) == 0x000054, "Member 'WidgetBlueprintLibrary_DrawLines::Thickness' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.DrawText
// 0x0058 (0x0058 - 0x0000)
struct WidgetBlueprintLibrary_DrawText final
{
public:
	struct FPaintContext                          Context;                                           // 0x0000(0x0030)(Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	class FString                                 inString;                                          // 0x0030(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              Position;                                          // 0x0040(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           Tint;                                              // 0x0048(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_DrawText) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_DrawText");
static_assert(sizeof(WidgetBlueprintLibrary_DrawText) == 0x000058, "Wrong size on WidgetBlueprintLibrary_DrawText");
static_assert(offsetof(WidgetBlueprintLibrary_DrawText, Context) == 0x000000, "Member 'WidgetBlueprintLibrary_DrawText::Context' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawText, inString) == 0x000030, "Member 'WidgetBlueprintLibrary_DrawText::inString' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawText, Position) == 0x000040, "Member 'WidgetBlueprintLibrary_DrawText::Position' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawText, Tint) == 0x000048, "Member 'WidgetBlueprintLibrary_DrawText::Tint' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.DrawTextFormatted
// 0x0078 (0x0078 - 0x0000)
struct WidgetBlueprintLibrary_DrawTextFormatted final
{
public:
	struct FPaintContext                          Context;                                           // 0x0000(0x0030)(Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	class FText                                   Text;                                              // 0x0030(0x0018)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FVector2D                              Position;                                          // 0x0048(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UFont*                                  Font;                                              // 0x0050(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         FontSize;                                          // 0x0058(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   FontTypeFace;                                      // 0x005C(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           Tint;                                              // 0x0064(0x0010)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_74[0x4];                                       // 0x0074(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_DrawTextFormatted) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_DrawTextFormatted");
static_assert(sizeof(WidgetBlueprintLibrary_DrawTextFormatted) == 0x000078, "Wrong size on WidgetBlueprintLibrary_DrawTextFormatted");
static_assert(offsetof(WidgetBlueprintLibrary_DrawTextFormatted, Context) == 0x000000, "Member 'WidgetBlueprintLibrary_DrawTextFormatted::Context' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawTextFormatted, Text) == 0x000030, "Member 'WidgetBlueprintLibrary_DrawTextFormatted::Text' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawTextFormatted, Position) == 0x000048, "Member 'WidgetBlueprintLibrary_DrawTextFormatted::Position' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawTextFormatted, Font) == 0x000050, "Member 'WidgetBlueprintLibrary_DrawTextFormatted::Font' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawTextFormatted, FontSize) == 0x000058, "Member 'WidgetBlueprintLibrary_DrawTextFormatted::FontSize' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawTextFormatted, FontTypeFace) == 0x00005C, "Member 'WidgetBlueprintLibrary_DrawTextFormatted::FontTypeFace' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_DrawTextFormatted, Tint) == 0x000064, "Member 'WidgetBlueprintLibrary_DrawTextFormatted::Tint' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.EndDragDrop
// 0x0170 (0x0170 - 0x0000)
struct WidgetBlueprintLibrary_EndDragDrop final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00B8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_EndDragDrop) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_EndDragDrop");
static_assert(sizeof(WidgetBlueprintLibrary_EndDragDrop) == 0x000170, "Wrong size on WidgetBlueprintLibrary_EndDragDrop");
static_assert(offsetof(WidgetBlueprintLibrary_EndDragDrop, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_EndDragDrop::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_EndDragDrop, ReturnValue) == 0x0000B8, "Member 'WidgetBlueprintLibrary_EndDragDrop::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetAllWidgetsOfClass
// 0x0028 (0x0028 - 0x0000)
struct WidgetBlueprintLibrary_GetAllWidgetsOfClass final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UUserWidget*>                    FoundWidgets;                                      // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TSubclassOf<class UUserWidget>                WidgetClass;                                       // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          TopLevelOnly;                                      // 0x0020(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x7];                                       // 0x0021(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_GetAllWidgetsOfClass) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetAllWidgetsOfClass");
static_assert(sizeof(WidgetBlueprintLibrary_GetAllWidgetsOfClass) == 0x000028, "Wrong size on WidgetBlueprintLibrary_GetAllWidgetsOfClass");
static_assert(offsetof(WidgetBlueprintLibrary_GetAllWidgetsOfClass, WorldContextObject) == 0x000000, "Member 'WidgetBlueprintLibrary_GetAllWidgetsOfClass::WorldContextObject' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetAllWidgetsOfClass, FoundWidgets) == 0x000008, "Member 'WidgetBlueprintLibrary_GetAllWidgetsOfClass::FoundWidgets' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetAllWidgetsOfClass, WidgetClass) == 0x000018, "Member 'WidgetBlueprintLibrary_GetAllWidgetsOfClass::WidgetClass' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetAllWidgetsOfClass, TopLevelOnly) == 0x000020, "Member 'WidgetBlueprintLibrary_GetAllWidgetsOfClass::TopLevelOnly' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetAllWidgetsWithInterface
// 0x0028 (0x0028 - 0x0000)
struct WidgetBlueprintLibrary_GetAllWidgetsWithInterface final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UUserWidget*>                    FoundWidgets;                                      // 0x0008(0x0010)(Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TSubclassOf<class IInterface>                 Interface;                                         // 0x0018(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          TopLevelOnly;                                      // 0x0020(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x7];                                       // 0x0021(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_GetAllWidgetsWithInterface) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetAllWidgetsWithInterface");
static_assert(sizeof(WidgetBlueprintLibrary_GetAllWidgetsWithInterface) == 0x000028, "Wrong size on WidgetBlueprintLibrary_GetAllWidgetsWithInterface");
static_assert(offsetof(WidgetBlueprintLibrary_GetAllWidgetsWithInterface, WorldContextObject) == 0x000000, "Member 'WidgetBlueprintLibrary_GetAllWidgetsWithInterface::WorldContextObject' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetAllWidgetsWithInterface, FoundWidgets) == 0x000008, "Member 'WidgetBlueprintLibrary_GetAllWidgetsWithInterface::FoundWidgets' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetAllWidgetsWithInterface, Interface) == 0x000018, "Member 'WidgetBlueprintLibrary_GetAllWidgetsWithInterface::Interface' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetAllWidgetsWithInterface, TopLevelOnly) == 0x000020, "Member 'WidgetBlueprintLibrary_GetAllWidgetsWithInterface::TopLevelOnly' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetBrushResource
// 0x0090 (0x0090 - 0x0000)
struct WidgetBlueprintLibrary_GetBrushResource final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UObject*                                ReturnValue;                                       // 0x0088(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetBrushResource) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetBrushResource");
static_assert(sizeof(WidgetBlueprintLibrary_GetBrushResource) == 0x000090, "Wrong size on WidgetBlueprintLibrary_GetBrushResource");
static_assert(offsetof(WidgetBlueprintLibrary_GetBrushResource, Brush) == 0x000000, "Member 'WidgetBlueprintLibrary_GetBrushResource::Brush' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetBrushResource, ReturnValue) == 0x000088, "Member 'WidgetBlueprintLibrary_GetBrushResource::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetBrushResourceAsMaterial
// 0x0090 (0x0090 - 0x0000)
struct WidgetBlueprintLibrary_GetBrushResourceAsMaterial final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     ReturnValue;                                       // 0x0088(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetBrushResourceAsMaterial) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetBrushResourceAsMaterial");
static_assert(sizeof(WidgetBlueprintLibrary_GetBrushResourceAsMaterial) == 0x000090, "Wrong size on WidgetBlueprintLibrary_GetBrushResourceAsMaterial");
static_assert(offsetof(WidgetBlueprintLibrary_GetBrushResourceAsMaterial, Brush) == 0x000000, "Member 'WidgetBlueprintLibrary_GetBrushResourceAsMaterial::Brush' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetBrushResourceAsMaterial, ReturnValue) == 0x000088, "Member 'WidgetBlueprintLibrary_GetBrushResourceAsMaterial::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetBrushResourceAsTexture2D
// 0x0090 (0x0090 - 0x0000)
struct WidgetBlueprintLibrary_GetBrushResourceAsTexture2D final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UTexture2D*                             ReturnValue;                                       // 0x0088(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetBrushResourceAsTexture2D) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetBrushResourceAsTexture2D");
static_assert(sizeof(WidgetBlueprintLibrary_GetBrushResourceAsTexture2D) == 0x000090, "Wrong size on WidgetBlueprintLibrary_GetBrushResourceAsTexture2D");
static_assert(offsetof(WidgetBlueprintLibrary_GetBrushResourceAsTexture2D, Brush) == 0x000000, "Member 'WidgetBlueprintLibrary_GetBrushResourceAsTexture2D::Brush' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetBrushResourceAsTexture2D, ReturnValue) == 0x000088, "Member 'WidgetBlueprintLibrary_GetBrushResourceAsTexture2D::ReturnValue' has a wrong offset!");

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

// Function UMG.WidgetBlueprintLibrary.GetDynamicMaterial
// 0x0090 (0x0090 - 0x0000)
struct WidgetBlueprintLibrary_GetDynamicMaterial final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ReturnValue;                                       // 0x0088(0x0008)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetDynamicMaterial) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetDynamicMaterial");
static_assert(sizeof(WidgetBlueprintLibrary_GetDynamicMaterial) == 0x000090, "Wrong size on WidgetBlueprintLibrary_GetDynamicMaterial");
static_assert(offsetof(WidgetBlueprintLibrary_GetDynamicMaterial, Brush) == 0x000000, "Member 'WidgetBlueprintLibrary_GetDynamicMaterial::Brush' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetDynamicMaterial, ReturnValue) == 0x000088, "Member 'WidgetBlueprintLibrary_GetDynamicMaterial::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetInputEventFromCharacterEvent
// 0x0038 (0x0038 - 0x0000)
struct WidgetBlueprintLibrary_GetInputEventFromCharacterEvent final
{
public:
	struct FCharacterEvent                        Event;                                             // 0x0000(0x0020)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FInputEvent                            ReturnValue;                                       // 0x0020(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetInputEventFromCharacterEvent) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetInputEventFromCharacterEvent");
static_assert(sizeof(WidgetBlueprintLibrary_GetInputEventFromCharacterEvent) == 0x000038, "Wrong size on WidgetBlueprintLibrary_GetInputEventFromCharacterEvent");
static_assert(offsetof(WidgetBlueprintLibrary_GetInputEventFromCharacterEvent, Event) == 0x000000, "Member 'WidgetBlueprintLibrary_GetInputEventFromCharacterEvent::Event' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetInputEventFromCharacterEvent, ReturnValue) == 0x000020, "Member 'WidgetBlueprintLibrary_GetInputEventFromCharacterEvent::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetInputEventFromKeyEvent
// 0x0050 (0x0050 - 0x0000)
struct WidgetBlueprintLibrary_GetInputEventFromKeyEvent final
{
public:
	struct FKeyEvent                              Event;                                             // 0x0000(0x0038)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FInputEvent                            ReturnValue;                                       // 0x0038(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetInputEventFromKeyEvent) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetInputEventFromKeyEvent");
static_assert(sizeof(WidgetBlueprintLibrary_GetInputEventFromKeyEvent) == 0x000050, "Wrong size on WidgetBlueprintLibrary_GetInputEventFromKeyEvent");
static_assert(offsetof(WidgetBlueprintLibrary_GetInputEventFromKeyEvent, Event) == 0x000000, "Member 'WidgetBlueprintLibrary_GetInputEventFromKeyEvent::Event' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetInputEventFromKeyEvent, ReturnValue) == 0x000038, "Member 'WidgetBlueprintLibrary_GetInputEventFromKeyEvent::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetInputEventFromNavigationEvent
// 0x0038 (0x0038 - 0x0000)
struct WidgetBlueprintLibrary_GetInputEventFromNavigationEvent final
{
public:
	struct FNavigationEvent                       Event;                                             // 0x0000(0x0020)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FInputEvent                            ReturnValue;                                       // 0x0020(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetInputEventFromNavigationEvent) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetInputEventFromNavigationEvent");
static_assert(sizeof(WidgetBlueprintLibrary_GetInputEventFromNavigationEvent) == 0x000038, "Wrong size on WidgetBlueprintLibrary_GetInputEventFromNavigationEvent");
static_assert(offsetof(WidgetBlueprintLibrary_GetInputEventFromNavigationEvent, Event) == 0x000000, "Member 'WidgetBlueprintLibrary_GetInputEventFromNavigationEvent::Event' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetInputEventFromNavigationEvent, ReturnValue) == 0x000020, "Member 'WidgetBlueprintLibrary_GetInputEventFromNavigationEvent::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetInputEventFromPointerEvent
// 0x0088 (0x0088 - 0x0000)
struct WidgetBlueprintLibrary_GetInputEventFromPointerEvent final
{
public:
	struct FPointerEvent                          Event;                                             // 0x0000(0x0070)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FInputEvent                            ReturnValue;                                       // 0x0070(0x0018)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetInputEventFromPointerEvent) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetInputEventFromPointerEvent");
static_assert(sizeof(WidgetBlueprintLibrary_GetInputEventFromPointerEvent) == 0x000088, "Wrong size on WidgetBlueprintLibrary_GetInputEventFromPointerEvent");
static_assert(offsetof(WidgetBlueprintLibrary_GetInputEventFromPointerEvent, Event) == 0x000000, "Member 'WidgetBlueprintLibrary_GetInputEventFromPointerEvent::Event' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetInputEventFromPointerEvent, ReturnValue) == 0x000070, "Member 'WidgetBlueprintLibrary_GetInputEventFromPointerEvent::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetKeyEventFromAnalogInputEvent
// 0x0078 (0x0078 - 0x0000)
struct WidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent final
{
public:
	struct FAnalogInputEvent                      Event;                                             // 0x0000(0x0040)(ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FKeyEvent                              ReturnValue;                                       // 0x0040(0x0038)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent");
static_assert(sizeof(WidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent) == 0x000078, "Wrong size on WidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent");
static_assert(offsetof(WidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent, Event) == 0x000000, "Member 'WidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent::Event' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent, ReturnValue) == 0x000040, "Member 'WidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.GetSafeZonePadding
// 0x0040 (0x0040 - 0x0000)
struct WidgetBlueprintLibrary_GetSafeZonePadding final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_8[0x8];                                        // 0x0008(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector4                               SafePadding;                                       // 0x0010(0x0010)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              SafePaddingScale;                                  // 0x0020(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector4                               SpillOverPadding;                                  // 0x0030(0x0010)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_GetSafeZonePadding) == 0x000010, "Wrong alignment on WidgetBlueprintLibrary_GetSafeZonePadding");
static_assert(sizeof(WidgetBlueprintLibrary_GetSafeZonePadding) == 0x000040, "Wrong size on WidgetBlueprintLibrary_GetSafeZonePadding");
static_assert(offsetof(WidgetBlueprintLibrary_GetSafeZonePadding, WorldContextObject) == 0x000000, "Member 'WidgetBlueprintLibrary_GetSafeZonePadding::WorldContextObject' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetSafeZonePadding, SafePadding) == 0x000010, "Member 'WidgetBlueprintLibrary_GetSafeZonePadding::SafePadding' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetSafeZonePadding, SafePaddingScale) == 0x000020, "Member 'WidgetBlueprintLibrary_GetSafeZonePadding::SafePaddingScale' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_GetSafeZonePadding, SpillOverPadding) == 0x000030, "Member 'WidgetBlueprintLibrary_GetSafeZonePadding::SpillOverPadding' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.Handled
// 0x00B8 (0x00B8 - 0x0000)
struct WidgetBlueprintLibrary_Handled final
{
public:
	struct FEventReply                            ReturnValue;                                       // 0x0000(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_Handled) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_Handled");
static_assert(sizeof(WidgetBlueprintLibrary_Handled) == 0x0000B8, "Wrong size on WidgetBlueprintLibrary_Handled");
static_assert(offsetof(WidgetBlueprintLibrary_Handled, ReturnValue) == 0x000000, "Member 'WidgetBlueprintLibrary_Handled::ReturnValue' has a wrong offset!");

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

// Function UMG.WidgetBlueprintLibrary.LockMouse
// 0x0178 (0x0178 - 0x0000)
struct WidgetBlueprintLibrary_LockMouse final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UWidget*                                CapturingWidget;                                   // 0x00B8(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00C0(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_LockMouse) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_LockMouse");
static_assert(sizeof(WidgetBlueprintLibrary_LockMouse) == 0x000178, "Wrong size on WidgetBlueprintLibrary_LockMouse");
static_assert(offsetof(WidgetBlueprintLibrary_LockMouse, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_LockMouse::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_LockMouse, CapturingWidget) == 0x0000B8, "Member 'WidgetBlueprintLibrary_LockMouse::CapturingWidget' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_LockMouse, ReturnValue) == 0x0000C0, "Member 'WidgetBlueprintLibrary_LockMouse::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.MakeBrushFromAsset
// 0x0090 (0x0090 - 0x0000)
struct WidgetBlueprintLibrary_MakeBrushFromAsset final
{
public:
	class USlateBrushAsset*                       BrushAsset;                                        // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateBrush                            ReturnValue;                                       // 0x0008(0x0088)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_MakeBrushFromAsset) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_MakeBrushFromAsset");
static_assert(sizeof(WidgetBlueprintLibrary_MakeBrushFromAsset) == 0x000090, "Wrong size on WidgetBlueprintLibrary_MakeBrushFromAsset");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromAsset, BrushAsset) == 0x000000, "Member 'WidgetBlueprintLibrary_MakeBrushFromAsset::BrushAsset' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromAsset, ReturnValue) == 0x000008, "Member 'WidgetBlueprintLibrary_MakeBrushFromAsset::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.MakeBrushFromMaterial
// 0x0098 (0x0098 - 0x0000)
struct WidgetBlueprintLibrary_MakeBrushFromMaterial final
{
public:
	class UMaterialInterface*                     Material;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Width;                                             // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Height;                                            // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateBrush                            ReturnValue;                                       // 0x0010(0x0088)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_MakeBrushFromMaterial) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_MakeBrushFromMaterial");
static_assert(sizeof(WidgetBlueprintLibrary_MakeBrushFromMaterial) == 0x000098, "Wrong size on WidgetBlueprintLibrary_MakeBrushFromMaterial");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromMaterial, Material) == 0x000000, "Member 'WidgetBlueprintLibrary_MakeBrushFromMaterial::Material' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromMaterial, Width) == 0x000008, "Member 'WidgetBlueprintLibrary_MakeBrushFromMaterial::Width' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromMaterial, Height) == 0x00000C, "Member 'WidgetBlueprintLibrary_MakeBrushFromMaterial::Height' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromMaterial, ReturnValue) == 0x000010, "Member 'WidgetBlueprintLibrary_MakeBrushFromMaterial::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.MakeBrushFromTexture
// 0x0098 (0x0098 - 0x0000)
struct WidgetBlueprintLibrary_MakeBrushFromTexture final
{
public:
	class UTexture2D*                             Texture;                                           // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Width;                                             // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Height;                                            // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateBrush                            ReturnValue;                                       // 0x0010(0x0088)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_MakeBrushFromTexture) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_MakeBrushFromTexture");
static_assert(sizeof(WidgetBlueprintLibrary_MakeBrushFromTexture) == 0x000098, "Wrong size on WidgetBlueprintLibrary_MakeBrushFromTexture");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromTexture, Texture) == 0x000000, "Member 'WidgetBlueprintLibrary_MakeBrushFromTexture::Texture' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromTexture, Width) == 0x000008, "Member 'WidgetBlueprintLibrary_MakeBrushFromTexture::Width' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromTexture, Height) == 0x00000C, "Member 'WidgetBlueprintLibrary_MakeBrushFromTexture::Height' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_MakeBrushFromTexture, ReturnValue) == 0x000010, "Member 'WidgetBlueprintLibrary_MakeBrushFromTexture::ReturnValue' has a wrong offset!");

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

// Function UMG.WidgetBlueprintLibrary.ReleaseJoystickCapture
// 0x0178 (0x0178 - 0x0000)
struct WidgetBlueprintLibrary_ReleaseJoystickCapture final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	bool                                          bInAllJoysticks;                                   // 0x00B8(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B9[0x7];                                       // 0x00B9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FEventReply                            ReturnValue;                                       // 0x00C0(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_ReleaseJoystickCapture) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_ReleaseJoystickCapture");
static_assert(sizeof(WidgetBlueprintLibrary_ReleaseJoystickCapture) == 0x000178, "Wrong size on WidgetBlueprintLibrary_ReleaseJoystickCapture");
static_assert(offsetof(WidgetBlueprintLibrary_ReleaseJoystickCapture, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_ReleaseJoystickCapture::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_ReleaseJoystickCapture, bInAllJoysticks) == 0x0000B8, "Member 'WidgetBlueprintLibrary_ReleaseJoystickCapture::bInAllJoysticks' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_ReleaseJoystickCapture, ReturnValue) == 0x0000C0, "Member 'WidgetBlueprintLibrary_ReleaseJoystickCapture::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.ReleaseMouseCapture
// 0x0170 (0x0170 - 0x0000)
struct WidgetBlueprintLibrary_ReleaseMouseCapture final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00B8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_ReleaseMouseCapture) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_ReleaseMouseCapture");
static_assert(sizeof(WidgetBlueprintLibrary_ReleaseMouseCapture) == 0x000170, "Wrong size on WidgetBlueprintLibrary_ReleaseMouseCapture");
static_assert(offsetof(WidgetBlueprintLibrary_ReleaseMouseCapture, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_ReleaseMouseCapture::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_ReleaseMouseCapture, ReturnValue) == 0x0000B8, "Member 'WidgetBlueprintLibrary_ReleaseMouseCapture::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetBrushResourceToMaterial
// 0x0090 (0x0090 - 0x0000)
struct WidgetBlueprintLibrary_SetBrushResourceToMaterial final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     Material;                                          // 0x0088(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_SetBrushResourceToMaterial) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetBrushResourceToMaterial");
static_assert(sizeof(WidgetBlueprintLibrary_SetBrushResourceToMaterial) == 0x000090, "Wrong size on WidgetBlueprintLibrary_SetBrushResourceToMaterial");
static_assert(offsetof(WidgetBlueprintLibrary_SetBrushResourceToMaterial, Brush) == 0x000000, "Member 'WidgetBlueprintLibrary_SetBrushResourceToMaterial::Brush' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetBrushResourceToMaterial, Material) == 0x000088, "Member 'WidgetBlueprintLibrary_SetBrushResourceToMaterial::Material' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetBrushResourceToTexture
// 0x0090 (0x0090 - 0x0000)
struct WidgetBlueprintLibrary_SetBrushResourceToTexture final
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0000(0x0088)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UTexture2D*                             Texture;                                           // 0x0088(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_SetBrushResourceToTexture) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetBrushResourceToTexture");
static_assert(sizeof(WidgetBlueprintLibrary_SetBrushResourceToTexture) == 0x000090, "Wrong size on WidgetBlueprintLibrary_SetBrushResourceToTexture");
static_assert(offsetof(WidgetBlueprintLibrary_SetBrushResourceToTexture, Brush) == 0x000000, "Member 'WidgetBlueprintLibrary_SetBrushResourceToTexture::Brush' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetBrushResourceToTexture, Texture) == 0x000088, "Member 'WidgetBlueprintLibrary_SetBrushResourceToTexture::Texture' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetColorVisionDeficiencyType
// 0x000C (0x000C - 0x0000)
struct WidgetBlueprintLibrary_SetColorVisionDeficiencyType final
{
public:
	EColorVisionDeficiency                        Type;                                              // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Severity;                                          // 0x0004(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          CorrectDeficiency;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ShowCorrectionWithDeficiency;                      // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x2];                                        // 0x000A(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_SetColorVisionDeficiencyType) == 0x000004, "Wrong alignment on WidgetBlueprintLibrary_SetColorVisionDeficiencyType");
static_assert(sizeof(WidgetBlueprintLibrary_SetColorVisionDeficiencyType) == 0x00000C, "Wrong size on WidgetBlueprintLibrary_SetColorVisionDeficiencyType");
static_assert(offsetof(WidgetBlueprintLibrary_SetColorVisionDeficiencyType, Type) == 0x000000, "Member 'WidgetBlueprintLibrary_SetColorVisionDeficiencyType::Type' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetColorVisionDeficiencyType, Severity) == 0x000004, "Member 'WidgetBlueprintLibrary_SetColorVisionDeficiencyType::Severity' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetColorVisionDeficiencyType, CorrectDeficiency) == 0x000008, "Member 'WidgetBlueprintLibrary_SetColorVisionDeficiencyType::CorrectDeficiency' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetColorVisionDeficiencyType, ShowCorrectionWithDeficiency) == 0x000009, "Member 'WidgetBlueprintLibrary_SetColorVisionDeficiencyType::ShowCorrectionWithDeficiency' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetHardwareCursor
// 0x0020 (0x0020 - 0x0000)
struct WidgetBlueprintLibrary_SetHardwareCursor final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMouseCursor                                  CursorShape;                                       // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   CursorName;                                        // 0x000C(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              HotSpot;                                           // 0x0014(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x001C(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_SetHardwareCursor) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetHardwareCursor");
static_assert(sizeof(WidgetBlueprintLibrary_SetHardwareCursor) == 0x000020, "Wrong size on WidgetBlueprintLibrary_SetHardwareCursor");
static_assert(offsetof(WidgetBlueprintLibrary_SetHardwareCursor, WorldContextObject) == 0x000000, "Member 'WidgetBlueprintLibrary_SetHardwareCursor::WorldContextObject' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetHardwareCursor, CursorShape) == 0x000008, "Member 'WidgetBlueprintLibrary_SetHardwareCursor::CursorShape' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetHardwareCursor, CursorName) == 0x00000C, "Member 'WidgetBlueprintLibrary_SetHardwareCursor::CursorName' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetHardwareCursor, HotSpot) == 0x000014, "Member 'WidgetBlueprintLibrary_SetHardwareCursor::HotSpot' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetHardwareCursor, ReturnValue) == 0x00001C, "Member 'WidgetBlueprintLibrary_SetHardwareCursor::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetInputMode_GameAndUI
// 0x0018 (0x0018 - 0x0000)
struct WidgetBlueprintLibrary_SetInputMode_GameAndUI final
{
public:
	class APlayerController*                      Target;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidget*                                InWidgetToFocus;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLockMouseToViewport;                              // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bHideCursorDuringCapture;                          // 0x0011(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12[0x6];                                       // 0x0012(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_SetInputMode_GameAndUI) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetInputMode_GameAndUI");
static_assert(sizeof(WidgetBlueprintLibrary_SetInputMode_GameAndUI) == 0x000018, "Wrong size on WidgetBlueprintLibrary_SetInputMode_GameAndUI");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_GameAndUI, Target) == 0x000000, "Member 'WidgetBlueprintLibrary_SetInputMode_GameAndUI::Target' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_GameAndUI, InWidgetToFocus) == 0x000008, "Member 'WidgetBlueprintLibrary_SetInputMode_GameAndUI::InWidgetToFocus' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_GameAndUI, bLockMouseToViewport) == 0x000010, "Member 'WidgetBlueprintLibrary_SetInputMode_GameAndUI::bLockMouseToViewport' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_GameAndUI, bHideCursorDuringCapture) == 0x000011, "Member 'WidgetBlueprintLibrary_SetInputMode_GameAndUI::bHideCursorDuringCapture' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetInputMode_GameAndUIEx
// 0x0018 (0x0018 - 0x0000)
struct WidgetBlueprintLibrary_SetInputMode_GameAndUIEx final
{
public:
	class APlayerController*                      PlayerController;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidget*                                InWidgetToFocus;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMouseLockMode                                InMouseLockMode;                                   // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bHideCursorDuringCapture;                          // 0x0011(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12[0x6];                                       // 0x0012(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_SetInputMode_GameAndUIEx) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetInputMode_GameAndUIEx");
static_assert(sizeof(WidgetBlueprintLibrary_SetInputMode_GameAndUIEx) == 0x000018, "Wrong size on WidgetBlueprintLibrary_SetInputMode_GameAndUIEx");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_GameAndUIEx, PlayerController) == 0x000000, "Member 'WidgetBlueprintLibrary_SetInputMode_GameAndUIEx::PlayerController' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_GameAndUIEx, InWidgetToFocus) == 0x000008, "Member 'WidgetBlueprintLibrary_SetInputMode_GameAndUIEx::InWidgetToFocus' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_GameAndUIEx, InMouseLockMode) == 0x000010, "Member 'WidgetBlueprintLibrary_SetInputMode_GameAndUIEx::InMouseLockMode' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_GameAndUIEx, bHideCursorDuringCapture) == 0x000011, "Member 'WidgetBlueprintLibrary_SetInputMode_GameAndUIEx::bHideCursorDuringCapture' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetInputMode_GameOnly
// 0x0008 (0x0008 - 0x0000)
struct WidgetBlueprintLibrary_SetInputMode_GameOnly final
{
public:
	class APlayerController*                      PlayerController;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_SetInputMode_GameOnly) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetInputMode_GameOnly");
static_assert(sizeof(WidgetBlueprintLibrary_SetInputMode_GameOnly) == 0x000008, "Wrong size on WidgetBlueprintLibrary_SetInputMode_GameOnly");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_GameOnly, PlayerController) == 0x000000, "Member 'WidgetBlueprintLibrary_SetInputMode_GameOnly::PlayerController' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetInputMode_UIOnly
// 0x0018 (0x0018 - 0x0000)
struct WidgetBlueprintLibrary_SetInputMode_UIOnly final
{
public:
	class APlayerController*                      Target;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidget*                                InWidgetToFocus;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLockMouseToViewport;                              // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_SetInputMode_UIOnly) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetInputMode_UIOnly");
static_assert(sizeof(WidgetBlueprintLibrary_SetInputMode_UIOnly) == 0x000018, "Wrong size on WidgetBlueprintLibrary_SetInputMode_UIOnly");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_UIOnly, Target) == 0x000000, "Member 'WidgetBlueprintLibrary_SetInputMode_UIOnly::Target' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_UIOnly, InWidgetToFocus) == 0x000008, "Member 'WidgetBlueprintLibrary_SetInputMode_UIOnly::InWidgetToFocus' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_UIOnly, bLockMouseToViewport) == 0x000010, "Member 'WidgetBlueprintLibrary_SetInputMode_UIOnly::bLockMouseToViewport' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetInputMode_UIOnlyEx
// 0x0018 (0x0018 - 0x0000)
struct WidgetBlueprintLibrary_SetInputMode_UIOnlyEx final
{
public:
	class APlayerController*                      PlayerController;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidget*                                InWidgetToFocus;                                   // 0x0008(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMouseLockMode                                InMouseLockMode;                                   // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_SetInputMode_UIOnlyEx) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetInputMode_UIOnlyEx");
static_assert(sizeof(WidgetBlueprintLibrary_SetInputMode_UIOnlyEx) == 0x000018, "Wrong size on WidgetBlueprintLibrary_SetInputMode_UIOnlyEx");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_UIOnlyEx, PlayerController) == 0x000000, "Member 'WidgetBlueprintLibrary_SetInputMode_UIOnlyEx::PlayerController' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_UIOnlyEx, InWidgetToFocus) == 0x000008, "Member 'WidgetBlueprintLibrary_SetInputMode_UIOnlyEx::InWidgetToFocus' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetInputMode_UIOnlyEx, InMouseLockMode) == 0x000010, "Member 'WidgetBlueprintLibrary_SetInputMode_UIOnlyEx::InMouseLockMode' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetMousePosition
// 0x0178 (0x0178 - 0x0000)
struct WidgetBlueprintLibrary_SetMousePosition final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FVector2D                              NewMousePosition;                                  // 0x00B8(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00C0(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_SetMousePosition) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetMousePosition");
static_assert(sizeof(WidgetBlueprintLibrary_SetMousePosition) == 0x000178, "Wrong size on WidgetBlueprintLibrary_SetMousePosition");
static_assert(offsetof(WidgetBlueprintLibrary_SetMousePosition, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_SetMousePosition::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetMousePosition, NewMousePosition) == 0x0000B8, "Member 'WidgetBlueprintLibrary_SetMousePosition::NewMousePosition' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetMousePosition, ReturnValue) == 0x0000C0, "Member 'WidgetBlueprintLibrary_SetMousePosition::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetUserFocus
// 0x0180 (0x0180 - 0x0000)
struct WidgetBlueprintLibrary_SetUserFocus final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	class UWidget*                                FocusWidget;                                       // 0x00B8(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInAllUsers;                                       // 0x00C0(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FEventReply                            ReturnValue;                                       // 0x00C8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_SetUserFocus) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetUserFocus");
static_assert(sizeof(WidgetBlueprintLibrary_SetUserFocus) == 0x000180, "Wrong size on WidgetBlueprintLibrary_SetUserFocus");
static_assert(offsetof(WidgetBlueprintLibrary_SetUserFocus, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_SetUserFocus::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetUserFocus, FocusWidget) == 0x0000B8, "Member 'WidgetBlueprintLibrary_SetUserFocus::FocusWidget' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetUserFocus, bInAllUsers) == 0x0000C0, "Member 'WidgetBlueprintLibrary_SetUserFocus::bInAllUsers' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetUserFocus, ReturnValue) == 0x0000C8, "Member 'WidgetBlueprintLibrary_SetUserFocus::ReturnValue' has a wrong offset!");

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

// Function UMG.WidgetBlueprintLibrary.SetWindowTitleBarOnCloseClickedDelegate
// 0x0010 (0x0010 - 0x0000)
struct WidgetBlueprintLibrary_SetWindowTitleBarOnCloseClickedDelegate final
{
public:
	TDelegate<void()>                             Delegate;                                          // 0x0000(0x0010)(Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_SetWindowTitleBarOnCloseClickedDelegate) == 0x000004, "Wrong alignment on WidgetBlueprintLibrary_SetWindowTitleBarOnCloseClickedDelegate");
static_assert(sizeof(WidgetBlueprintLibrary_SetWindowTitleBarOnCloseClickedDelegate) == 0x000010, "Wrong size on WidgetBlueprintLibrary_SetWindowTitleBarOnCloseClickedDelegate");
static_assert(offsetof(WidgetBlueprintLibrary_SetWindowTitleBarOnCloseClickedDelegate, Delegate) == 0x000000, "Member 'WidgetBlueprintLibrary_SetWindowTitleBarOnCloseClickedDelegate::Delegate' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.SetWindowTitleBarState
// 0x0010 (0x0010 - 0x0000)
struct WidgetBlueprintLibrary_SetWindowTitleBarState final
{
public:
	class UWidget*                                TitleBarContent;                                   // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EWindowTitleBarMode                           Mode;                                              // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTitleBarDragEnabled;                              // 0x0009(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bWindowButtonsVisible;                             // 0x000A(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTitleBarVisible;                                  // 0x000B(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetBlueprintLibrary_SetWindowTitleBarState) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_SetWindowTitleBarState");
static_assert(sizeof(WidgetBlueprintLibrary_SetWindowTitleBarState) == 0x000010, "Wrong size on WidgetBlueprintLibrary_SetWindowTitleBarState");
static_assert(offsetof(WidgetBlueprintLibrary_SetWindowTitleBarState, TitleBarContent) == 0x000000, "Member 'WidgetBlueprintLibrary_SetWindowTitleBarState::TitleBarContent' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetWindowTitleBarState, Mode) == 0x000008, "Member 'WidgetBlueprintLibrary_SetWindowTitleBarState::Mode' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetWindowTitleBarState, bTitleBarDragEnabled) == 0x000009, "Member 'WidgetBlueprintLibrary_SetWindowTitleBarState::bTitleBarDragEnabled' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetWindowTitleBarState, bWindowButtonsVisible) == 0x00000A, "Member 'WidgetBlueprintLibrary_SetWindowTitleBarState::bWindowButtonsVisible' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_SetWindowTitleBarState, bTitleBarVisible) == 0x00000B, "Member 'WidgetBlueprintLibrary_SetWindowTitleBarState::bTitleBarVisible' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.Unhandled
// 0x00B8 (0x00B8 - 0x0000)
struct WidgetBlueprintLibrary_Unhandled final
{
public:
	struct FEventReply                            ReturnValue;                                       // 0x0000(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_Unhandled) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_Unhandled");
static_assert(sizeof(WidgetBlueprintLibrary_Unhandled) == 0x0000B8, "Wrong size on WidgetBlueprintLibrary_Unhandled");
static_assert(offsetof(WidgetBlueprintLibrary_Unhandled, ReturnValue) == 0x000000, "Member 'WidgetBlueprintLibrary_Unhandled::ReturnValue' has a wrong offset!");

// Function UMG.WidgetBlueprintLibrary.UnlockMouse
// 0x0170 (0x0170 - 0x0000)
struct WidgetBlueprintLibrary_UnlockMouse final
{
public:
	struct FEventReply                            Reply;                                             // 0x0000(0x00B8)(Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
	struct FEventReply                            ReturnValue;                                       // 0x00B8(0x00B8)(Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetBlueprintLibrary_UnlockMouse) == 0x000008, "Wrong alignment on WidgetBlueprintLibrary_UnlockMouse");
static_assert(sizeof(WidgetBlueprintLibrary_UnlockMouse) == 0x000170, "Wrong size on WidgetBlueprintLibrary_UnlockMouse");
static_assert(offsetof(WidgetBlueprintLibrary_UnlockMouse, Reply) == 0x000000, "Member 'WidgetBlueprintLibrary_UnlockMouse::Reply' has a wrong offset!");
static_assert(offsetof(WidgetBlueprintLibrary_UnlockMouse, ReturnValue) == 0x0000B8, "Member 'WidgetBlueprintLibrary_UnlockMouse::ReturnValue' has a wrong offset!");

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

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

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

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

// Function UMG.WidgetComponent.SetGeometryMode
// 0x0001 (0x0001 - 0x0000)
struct WidgetComponent_SetGeometryMode final
{
public:
	EWidgetGeometryMode                           InGeometryMode;                                    // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetComponent_SetGeometryMode) == 0x000001, "Wrong alignment on WidgetComponent_SetGeometryMode");
static_assert(sizeof(WidgetComponent_SetGeometryMode) == 0x000001, "Wrong size on WidgetComponent_SetGeometryMode");
static_assert(offsetof(WidgetComponent_SetGeometryMode, InGeometryMode) == 0x000000, "Member 'WidgetComponent_SetGeometryMode::InGeometryMode' has a wrong offset!");

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

// Function UMG.WidgetComponent.SetOwnerPlayer
// 0x0008 (0x0008 - 0x0000)
struct WidgetComponent_SetOwnerPlayer final
{
public:
	class ULocalPlayer*                           LocalPlayer;                                       // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetComponent_SetOwnerPlayer) == 0x000008, "Wrong alignment on WidgetComponent_SetOwnerPlayer");
static_assert(sizeof(WidgetComponent_SetOwnerPlayer) == 0x000008, "Wrong size on WidgetComponent_SetOwnerPlayer");
static_assert(offsetof(WidgetComponent_SetOwnerPlayer, LocalPlayer) == 0x000000, "Member 'WidgetComponent_SetOwnerPlayer::LocalPlayer' has a wrong offset!");

// Function UMG.WidgetComponent.SetPivot
// 0x0008 (0x0008 - 0x0000)
struct WidgetComponent_SetPivot final
{
public:
	struct FVector2D                              InPivot;                                           // 0x0000(0x0008)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetComponent_SetPivot) == 0x000004, "Wrong alignment on WidgetComponent_SetPivot");
static_assert(sizeof(WidgetComponent_SetPivot) == 0x000008, "Wrong size on WidgetComponent_SetPivot");
static_assert(offsetof(WidgetComponent_SetPivot, InPivot) == 0x000000, "Member 'WidgetComponent_SetPivot::InPivot' has a wrong offset!");

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

// Function UMG.WidgetComponent.SetTickMode
// 0x0001 (0x0001 - 0x0000)
struct WidgetComponent_SetTickMode final
{
public:
	ETickMode                                     InTickMode;                                        // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetComponent_SetTickMode) == 0x000001, "Wrong alignment on WidgetComponent_SetTickMode");
static_assert(sizeof(WidgetComponent_SetTickMode) == 0x000001, "Wrong size on WidgetComponent_SetTickMode");
static_assert(offsetof(WidgetComponent_SetTickMode, InTickMode) == 0x000000, "Member 'WidgetComponent_SetTickMode::InTickMode' has a wrong offset!");

// Function UMG.WidgetComponent.SetTickWhenOffscreen
// 0x0001 (0x0001 - 0x0000)
struct WidgetComponent_SetTickWhenOffscreen final
{
public:
	bool                                          bWantTickWhenOffscreen;                            // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetComponent_SetTickWhenOffscreen) == 0x000001, "Wrong alignment on WidgetComponent_SetTickWhenOffscreen");
static_assert(sizeof(WidgetComponent_SetTickWhenOffscreen) == 0x000001, "Wrong size on WidgetComponent_SetTickWhenOffscreen");
static_assert(offsetof(WidgetComponent_SetTickWhenOffscreen, bWantTickWhenOffscreen) == 0x000000, "Member 'WidgetComponent_SetTickWhenOffscreen::bWantTickWhenOffscreen' has a wrong offset!");

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

// Function UMG.WidgetComponent.SetTwoSided
// 0x0001 (0x0001 - 0x0000)
struct WidgetComponent_SetTwoSided final
{
public:
	bool                                          bWantTwoSided;                                     // 0x0000(0x0001)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetComponent_SetTwoSided) == 0x000001, "Wrong alignment on WidgetComponent_SetTwoSided");
static_assert(sizeof(WidgetComponent_SetTwoSided) == 0x000001, "Wrong size on WidgetComponent_SetTwoSided");
static_assert(offsetof(WidgetComponent_SetTwoSided, bWantTwoSided) == 0x000000, "Member 'WidgetComponent_SetTwoSided::bWantTwoSided' has a wrong offset!");

// Function UMG.WidgetComponent.SetWidget
// 0x0008 (0x0008 - 0x0000)
struct WidgetComponent_SetWidget final
{
public:
	class UUserWidget*                            Widget_0;                                          // 0x0000(0x0008)(Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetComponent_SetWidget) == 0x000008, "Wrong alignment on WidgetComponent_SetWidget");
static_assert(sizeof(WidgetComponent_SetWidget) == 0x000008, "Wrong size on WidgetComponent_SetWidget");
static_assert(offsetof(WidgetComponent_SetWidget, Widget_0) == 0x000000, "Member 'WidgetComponent_SetWidget::Widget_0' has a wrong offset!");

// Function UMG.WidgetComponent.SetWidgetSpace
// 0x0001 (0x0001 - 0x0000)
struct WidgetComponent_SetWidgetSpace final
{
public:
	EWidgetSpace                                  NewSpace;                                          // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetComponent_SetWidgetSpace) == 0x000001, "Wrong alignment on WidgetComponent_SetWidgetSpace");
static_assert(sizeof(WidgetComponent_SetWidgetSpace) == 0x000001, "Wrong size on WidgetComponent_SetWidgetSpace");
static_assert(offsetof(WidgetComponent_SetWidgetSpace, NewSpace) == 0x000000, "Member 'WidgetComponent_SetWidgetSpace::NewSpace' has a wrong offset!");

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

// Function UMG.WidgetComponent.SetWindowVisibility
// 0x0001 (0x0001 - 0x0000)
struct WidgetComponent_SetWindowVisibility final
{
public:
	EWindowVisibility                             InVisibility;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetComponent_SetWindowVisibility) == 0x000001, "Wrong alignment on WidgetComponent_SetWindowVisibility");
static_assert(sizeof(WidgetComponent_SetWindowVisibility) == 0x000001, "Wrong size on WidgetComponent_SetWindowVisibility");
static_assert(offsetof(WidgetComponent_SetWindowVisibility, InVisibility) == 0x000000, "Member 'WidgetComponent_SetWindowVisibility::InVisibility' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Function UMG.WidgetInteractionComponent.PressAndReleaseKey
// 0x0020 (0x0020 - 0x0000)
struct WidgetInteractionComponent_PressAndReleaseKey final
{
public:
	struct FKey                                   Key;                                               // 0x0000(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetInteractionComponent_PressAndReleaseKey) == 0x000008, "Wrong alignment on WidgetInteractionComponent_PressAndReleaseKey");
static_assert(sizeof(WidgetInteractionComponent_PressAndReleaseKey) == 0x000020, "Wrong size on WidgetInteractionComponent_PressAndReleaseKey");
static_assert(offsetof(WidgetInteractionComponent_PressAndReleaseKey, Key) == 0x000000, "Member 'WidgetInteractionComponent_PressAndReleaseKey::Key' has a wrong offset!");
static_assert(offsetof(WidgetInteractionComponent_PressAndReleaseKey, ReturnValue) == 0x000018, "Member 'WidgetInteractionComponent_PressAndReleaseKey::ReturnValue' has a wrong offset!");

// Function UMG.WidgetInteractionComponent.PressKey
// 0x0020 (0x0020 - 0x0000)
struct WidgetInteractionComponent_PressKey final
{
public:
	struct FKey                                   Key;                                               // 0x0000(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRepeat;                                           // 0x0018(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0019(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1A[0x6];                                       // 0x001A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetInteractionComponent_PressKey) == 0x000008, "Wrong alignment on WidgetInteractionComponent_PressKey");
static_assert(sizeof(WidgetInteractionComponent_PressKey) == 0x000020, "Wrong size on WidgetInteractionComponent_PressKey");
static_assert(offsetof(WidgetInteractionComponent_PressKey, Key) == 0x000000, "Member 'WidgetInteractionComponent_PressKey::Key' has a wrong offset!");
static_assert(offsetof(WidgetInteractionComponent_PressKey, bRepeat) == 0x000018, "Member 'WidgetInteractionComponent_PressKey::bRepeat' has a wrong offset!");
static_assert(offsetof(WidgetInteractionComponent_PressKey, ReturnValue) == 0x000019, "Member 'WidgetInteractionComponent_PressKey::ReturnValue' has a wrong offset!");

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

// Function UMG.WidgetInteractionComponent.ReleaseKey
// 0x0020 (0x0020 - 0x0000)
struct WidgetInteractionComponent_ReleaseKey final
{
public:
	struct FKey                                   Key;                                               // 0x0000(0x0018)(Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0018(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetInteractionComponent_ReleaseKey) == 0x000008, "Wrong alignment on WidgetInteractionComponent_ReleaseKey");
static_assert(sizeof(WidgetInteractionComponent_ReleaseKey) == 0x000020, "Wrong size on WidgetInteractionComponent_ReleaseKey");
static_assert(offsetof(WidgetInteractionComponent_ReleaseKey, Key) == 0x000000, "Member 'WidgetInteractionComponent_ReleaseKey::Key' has a wrong offset!");
static_assert(offsetof(WidgetInteractionComponent_ReleaseKey, ReturnValue) == 0x000018, "Member 'WidgetInteractionComponent_ReleaseKey::ReturnValue' has a wrong offset!");

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

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

// Function UMG.WidgetInteractionComponent.SendKeyChar
// 0x0018 (0x0018 - 0x0000)
struct WidgetInteractionComponent_SendKeyChar final
{
public:
	class FString                                 Characters;                                        // 0x0000(0x0010)(Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRepeat;                                           // 0x0010(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0011(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12[0x6];                                       // 0x0012(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetInteractionComponent_SendKeyChar) == 0x000008, "Wrong alignment on WidgetInteractionComponent_SendKeyChar");
static_assert(sizeof(WidgetInteractionComponent_SendKeyChar) == 0x000018, "Wrong size on WidgetInteractionComponent_SendKeyChar");
static_assert(offsetof(WidgetInteractionComponent_SendKeyChar, Characters) == 0x000000, "Member 'WidgetInteractionComponent_SendKeyChar::Characters' has a wrong offset!");
static_assert(offsetof(WidgetInteractionComponent_SendKeyChar, bRepeat) == 0x000010, "Member 'WidgetInteractionComponent_SendKeyChar::bRepeat' has a wrong offset!");
static_assert(offsetof(WidgetInteractionComponent_SendKeyChar, ReturnValue) == 0x000011, "Member 'WidgetInteractionComponent_SendKeyChar::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

// Function UMG.WidgetLayoutLibrary.GetMousePositionScaledByDPI
// 0x0018 (0x0018 - 0x0000)
struct WidgetLayoutLibrary_GetMousePositionScaledByDPI final
{
public:
	class APlayerController*                      Player;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LocationX;                                         // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LocationY;                                         // 0x000C(0x0004)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x0010(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetLayoutLibrary_GetMousePositionScaledByDPI) == 0x000008, "Wrong alignment on WidgetLayoutLibrary_GetMousePositionScaledByDPI");
static_assert(sizeof(WidgetLayoutLibrary_GetMousePositionScaledByDPI) == 0x000018, "Wrong size on WidgetLayoutLibrary_GetMousePositionScaledByDPI");
static_assert(offsetof(WidgetLayoutLibrary_GetMousePositionScaledByDPI, Player) == 0x000000, "Member 'WidgetLayoutLibrary_GetMousePositionScaledByDPI::Player' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_GetMousePositionScaledByDPI, LocationX) == 0x000008, "Member 'WidgetLayoutLibrary_GetMousePositionScaledByDPI::LocationX' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_GetMousePositionScaledByDPI, LocationY) == 0x00000C, "Member 'WidgetLayoutLibrary_GetMousePositionScaledByDPI::LocationY' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_GetMousePositionScaledByDPI, ReturnValue) == 0x000010, "Member 'WidgetLayoutLibrary_GetMousePositionScaledByDPI::ReturnValue' has a wrong offset!");

// Function UMG.WidgetLayoutLibrary.GetPlayerScreenWidgetGeometry
// 0x0040 (0x0040 - 0x0000)
struct WidgetLayoutLibrary_GetPlayerScreenWidgetGeometry final
{
public:
	class APlayerController*                      PlayerController;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGeometry                              ReturnValue;                                       // 0x0008(0x0038)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetLayoutLibrary_GetPlayerScreenWidgetGeometry) == 0x000008, "Wrong alignment on WidgetLayoutLibrary_GetPlayerScreenWidgetGeometry");
static_assert(sizeof(WidgetLayoutLibrary_GetPlayerScreenWidgetGeometry) == 0x000040, "Wrong size on WidgetLayoutLibrary_GetPlayerScreenWidgetGeometry");
static_assert(offsetof(WidgetLayoutLibrary_GetPlayerScreenWidgetGeometry, PlayerController) == 0x000000, "Member 'WidgetLayoutLibrary_GetPlayerScreenWidgetGeometry::PlayerController' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_GetPlayerScreenWidgetGeometry, ReturnValue) == 0x000008, "Member 'WidgetLayoutLibrary_GetPlayerScreenWidgetGeometry::ReturnValue' has a wrong offset!");

// Function UMG.WidgetLayoutLibrary.GetViewportScale
// 0x0010 (0x0010 - 0x0000)
struct WidgetLayoutLibrary_GetViewportScale final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReturnValue;                                       // 0x0008(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetLayoutLibrary_GetViewportScale) == 0x000008, "Wrong alignment on WidgetLayoutLibrary_GetViewportScale");
static_assert(sizeof(WidgetLayoutLibrary_GetViewportScale) == 0x000010, "Wrong size on WidgetLayoutLibrary_GetViewportScale");
static_assert(offsetof(WidgetLayoutLibrary_GetViewportScale, WorldContextObject) == 0x000000, "Member 'WidgetLayoutLibrary_GetViewportScale::WorldContextObject' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_GetViewportScale, ReturnValue) == 0x000008, "Member 'WidgetLayoutLibrary_GetViewportScale::ReturnValue' has a wrong offset!");

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

// Function UMG.WidgetLayoutLibrary.GetViewportWidgetGeometry
// 0x0040 (0x0040 - 0x0000)
struct WidgetLayoutLibrary_GetViewportWidgetGeometry final
{
public:
	class UObject*                                WorldContextObject;                                // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGeometry                              ReturnValue;                                       // 0x0008(0x0038)(Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(WidgetLayoutLibrary_GetViewportWidgetGeometry) == 0x000008, "Wrong alignment on WidgetLayoutLibrary_GetViewportWidgetGeometry");
static_assert(sizeof(WidgetLayoutLibrary_GetViewportWidgetGeometry) == 0x000040, "Wrong size on WidgetLayoutLibrary_GetViewportWidgetGeometry");
static_assert(offsetof(WidgetLayoutLibrary_GetViewportWidgetGeometry, WorldContextObject) == 0x000000, "Member 'WidgetLayoutLibrary_GetViewportWidgetGeometry::WorldContextObject' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_GetViewportWidgetGeometry, ReturnValue) == 0x000008, "Member 'WidgetLayoutLibrary_GetViewportWidgetGeometry::ReturnValue' has a wrong offset!");

// Function UMG.WidgetLayoutLibrary.ProjectWorldLocationToWidgetPosition
// 0x0020 (0x0020 - 0x0000)
struct WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition final
{
public:
	class APlayerController*                      PlayerController;                                  // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                WorldLocation;                                     // 0x0008(0x000C)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              ScreenPosition;                                    // 0x0014(0x0008)(Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bPlayerViewportRelative;                           // 0x001C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReturnValue;                                       // 0x001D(0x0001)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1E[0x2];                                       // 0x001E(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition) == 0x000008, "Wrong alignment on WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition");
static_assert(sizeof(WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition) == 0x000020, "Wrong size on WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition");
static_assert(offsetof(WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition, PlayerController) == 0x000000, "Member 'WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition::PlayerController' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition, WorldLocation) == 0x000008, "Member 'WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition::WorldLocation' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition, ScreenPosition) == 0x000014, "Member 'WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition::ScreenPosition' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition, bPlayerViewportRelative) == 0x00001C, "Member 'WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition::bPlayerViewportRelative' has a wrong offset!");
static_assert(offsetof(WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition, ReturnValue) == 0x00001D, "Member 'WidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition::ReturnValue' has a wrong offset!");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

