#pragma once

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

// Package: UMG

#include "Basic.hpp"

#include "InputCore_structs.hpp"
#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"
#include "Slate_structs.hpp"
#include "SlateCore_structs.hpp"
#include "UMG_structs.hpp"
#include "Engine_structs.hpp"
#include "Engine_classes.hpp"
#include "MovieScene_structs.hpp"
#include "MovieScene_classes.hpp"
#include "MovieSceneTracks_classes.hpp"


namespace SDK
{

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

// Class UMG.Widget
// 0x00E0 (0x0108 - 0x0028)
class UWidget : public UVisual
{
public:
	class UPanelSlot*                             Slot;                                              // 0x0028(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             bIsEnabledDelegate;                                // 0x0030(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	class FText                                   ToolTipText;                                       // 0x0040(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ToolTipTextDelegate;                               // 0x0058(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	class UWidget*                                ToolTipWidget;                                     // 0x0068(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ToolTipWidgetDelegate;                             // 0x0070(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void()>                             VisibilityDelegate;                                // 0x0080(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FWidgetTransform                       RenderTransform;                                   // 0x0090(0x001C)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              RenderTransformPivot;                              // 0x00AC(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsVariable : 1;                                   // 0x00B4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCreatedByConstructionScript : 1;                  // 0x00B4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsEnabled : 1;                                    // 0x00B4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverride_Cursor : 1;                              // 0x00B4(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsVolatile : 1;                                   // 0x00B4(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	EMouseCursor                                  Cursor;                                            // 0x00B5(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EWidgetClipping                               Clipping;                                          // 0x00B6(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESlateVisibility                              Visibility;                                        // 0x00B7(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RenderOpacity;                                     // 0x00B8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BC[0x4];                                       // 0x00BC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UWidgetNavigation*                      Navigation;                                        // 0x00C0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EFlowDirectionPreference                      FlowDirectionPreference;                           // 0x00C8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C9[0x2F];                                      // 0x00C9(0x002F)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UPropertyBinding*>               NativeBindings;                                    // 0x00F8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)

public:
	void ForceLayoutPrepass();
	void ForceVolatile(bool bForce);
	class UWidget* GenerateWidgetForObject__DelegateSignature(class UObject* Item);
	class UWidget* GenerateWidgetForString__DelegateSignature(const class FString& Item);
	bool GetBool__DelegateSignature();
	ECheckBoxState GetCheckBoxState__DelegateSignature();
	float GetFloat__DelegateSignature();
	int32 GetInt32__DelegateSignature();
	struct FLinearColor GetLinearColor__DelegateSignature();
	EMouseCursor GetMouseCursor__DelegateSignature();
	struct FSlateBrush GetSlateBrush__DelegateSignature();
	struct FSlateColor GetSlateColor__DelegateSignature();
	ESlateVisibility GetSlateVisibility__DelegateSignature();
	class FText GetText__DelegateSignature();
	class UWidget* GetWidget__DelegateSignature();
	void InvalidateLayoutAndVolatility();
	struct FEventReply OnPointerEvent__DelegateSignature(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent);
	struct FEventReply OnReply__DelegateSignature();
	void RemoveFromParent();
	void ResetCursor();
	void SetAllNavigationRules(EUINavigationRule Rule, class FName WidgetToFocus);
	void SetClipping(EWidgetClipping InClipping);
	void SetCursor(EMouseCursor InCursor);
	void SetIsEnabled(bool bInIsEnabled);
	void SetKeyboardFocus();
	void SetNavigationRule(EUINavigation Direction, EUINavigationRule Rule, class FName WidgetToFocus);
	void SetRenderAngle(float Angle);
	void SetRenderOpacity(float InOpacity);
	void SetRenderScale(const struct FVector2D& Scale);
	void SetRenderShear(const struct FVector2D& Shear);
	void SetRenderTransform(const struct FWidgetTransform& InTransform);
	void SetRenderTransformPivot(const struct FVector2D& Pivot);
	void SetRenderTranslation(const struct FVector2D& Translation);
	void SetToolTip(class UWidget* Widget);
	void SetToolTipText(const class FText& InToolTipText);
	void SetUserFocus(class APlayerController* PlayerController);
	void SetVisibility(ESlateVisibility InVisibility);

	const struct FGeometry GetCachedGeometry() const;
	EWidgetClipping GetClipping() const;
	struct FVector2D GetDesiredSize() const;
	class UGameInstance* GetGameInstance() const;
	bool GetIsEnabled() const;
	class ULocalPlayer* GetOwningLocalPlayer() const;
	class APlayerController* GetOwningPlayer() const;
	class UPanelWidget* GetParent() const;
	float GetRenderOpacity() const;
	ESlateVisibility GetVisibility() const;
	bool HasAnyUserFocus() const;
	bool HasFocusedDescendants() const;
	bool HasKeyboardFocus() const;
	bool HasMouseCapture() const;
	bool HasMouseCaptureByUser(int32 UserIndex, int32 PointerIndex) const;
	bool HasUserFocus(class APlayerController* PlayerController) const;
	bool HasUserFocusedDescendants(class APlayerController* PlayerController) const;
	bool IsHovered() const;
	bool IsVisible() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Widget">();
	}
	static class UWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWidget>();
	}
};
static_assert(alignof(UWidget) == 0x000008, "Wrong alignment on UWidget");
static_assert(sizeof(UWidget) == 0x000108, "Wrong size on UWidget");
static_assert(offsetof(UWidget, Slot) == 0x000028, "Member 'UWidget::Slot' has a wrong offset!");
static_assert(offsetof(UWidget, bIsEnabledDelegate) == 0x000030, "Member 'UWidget::bIsEnabledDelegate' has a wrong offset!");
static_assert(offsetof(UWidget, ToolTipText) == 0x000040, "Member 'UWidget::ToolTipText' has a wrong offset!");
static_assert(offsetof(UWidget, ToolTipTextDelegate) == 0x000058, "Member 'UWidget::ToolTipTextDelegate' has a wrong offset!");
static_assert(offsetof(UWidget, ToolTipWidget) == 0x000068, "Member 'UWidget::ToolTipWidget' has a wrong offset!");
static_assert(offsetof(UWidget, ToolTipWidgetDelegate) == 0x000070, "Member 'UWidget::ToolTipWidgetDelegate' has a wrong offset!");
static_assert(offsetof(UWidget, VisibilityDelegate) == 0x000080, "Member 'UWidget::VisibilityDelegate' has a wrong offset!");
static_assert(offsetof(UWidget, RenderTransform) == 0x000090, "Member 'UWidget::RenderTransform' has a wrong offset!");
static_assert(offsetof(UWidget, RenderTransformPivot) == 0x0000AC, "Member 'UWidget::RenderTransformPivot' has a wrong offset!");
static_assert(offsetof(UWidget, Cursor) == 0x0000B5, "Member 'UWidget::Cursor' has a wrong offset!");
static_assert(offsetof(UWidget, Clipping) == 0x0000B6, "Member 'UWidget::Clipping' has a wrong offset!");
static_assert(offsetof(UWidget, Visibility) == 0x0000B7, "Member 'UWidget::Visibility' has a wrong offset!");
static_assert(offsetof(UWidget, RenderOpacity) == 0x0000B8, "Member 'UWidget::RenderOpacity' has a wrong offset!");
static_assert(offsetof(UWidget, Navigation) == 0x0000C0, "Member 'UWidget::Navigation' has a wrong offset!");
static_assert(offsetof(UWidget, FlowDirectionPreference) == 0x0000C8, "Member 'UWidget::FlowDirectionPreference' has a wrong offset!");
static_assert(offsetof(UWidget, NativeBindings) == 0x0000F8, "Member 'UWidget::NativeBindings' has a wrong offset!");

// Class UMG.PanelWidget
// 0x0018 (0x0120 - 0x0108)
class UPanelWidget : public UWidget
{
public:
	TArray<class UPanelSlot*>                     Slots;                                             // 0x0108(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_118[0x8];                                      // 0x0118(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UPanelSlot* AddChild(class UWidget* Content);
	void ClearChildren();
	bool RemoveChild(class UWidget* Content);
	bool RemoveChildAt(int32 Param_Index);

	class UWidget* GetChildAt(int32 Param_Index) const;
	int32 GetChildIndex(const class UWidget* Content) const;
	int32 GetChildrenCount() const;
	bool HasAnyChildren() const;
	bool HasChild(class UWidget* Content) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PanelWidget">();
	}
	static class UPanelWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPanelWidget>();
	}
};
static_assert(alignof(UPanelWidget) == 0x000008, "Wrong alignment on UPanelWidget");
static_assert(sizeof(UPanelWidget) == 0x000120, "Wrong size on UPanelWidget");
static_assert(offsetof(UPanelWidget, Slots) == 0x000108, "Member 'UPanelWidget::Slots' has a wrong offset!");

// Class UMG.ContentWidget
// 0x0000 (0x0120 - 0x0120)
class UContentWidget : public UPanelWidget
{
public:
	class UPanelSlot* SetContent(class UWidget* Content);

	class UWidget* GetContent() const;
	class UPanelSlot* GetContentSlot() const;

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

// Class UMG.InvalidationBox
// 0x0018 (0x0138 - 0x0120)
class UInvalidationBox final : public UContentWidget
{
public:
	bool                                          bCanCache;                                         // 0x0120(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          CacheRelativeTransforms;                           // 0x0121(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_122[0x16];                                     // 0x0122(0x0016)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void InvalidateCache();
	void SetCanCache(bool CanCache);

	bool GetCanCache() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InvalidationBox">();
	}
	static class UInvalidationBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInvalidationBox>();
	}
};
static_assert(alignof(UInvalidationBox) == 0x000008, "Wrong alignment on UInvalidationBox");
static_assert(sizeof(UInvalidationBox) == 0x000138, "Wrong size on UInvalidationBox");
static_assert(offsetof(UInvalidationBox, bCanCache) == 0x000120, "Member 'UInvalidationBox::bCanCache' has a wrong offset!");
static_assert(offsetof(UInvalidationBox, CacheRelativeTransforms) == 0x000121, "Member 'UInvalidationBox::CacheRelativeTransforms' has a wrong offset!");

// Class UMG.UserWidget
// 0x0128 (0x0230 - 0x0108)
class UUserWidget : public UWidget
{
public:
	uint8                                         Pad_108[0x8];                                      // 0x0108(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FLinearColor                           ColorAndOpacity;                                   // 0x0110(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ColorAndOpacityDelegate;                           // 0x0120(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FSlateColor                            ForegroundColor;                                   // 0x0130(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ForegroundColorDelegate;                           // 0x0158(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FMargin                                Padding;                                           // 0x0168(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	TArray<class UUMGSequencePlayer*>             ActiveSequencePlayers;                             // 0x0178(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	TArray<class UUMGSequencePlayer*>             StoppedSequencePlayers;                            // 0x0188(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	TArray<struct FNamedSlotBinding>              NamedSlotBindings;                                 // 0x0198(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	class UWidgetTree*                            WidgetTree;                                        // 0x01A8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Priority;                                          // 0x01B0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bSupportsKeyboardFocus : 1;                        // 0x01B4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsFocusable : 1;                                  // 0x01B4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStopAction : 1;                                   // 0x01B4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasScriptImplementedTick : 1;                     // 0x01B4(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasScriptImplementedPaint : 1;                    // 0x01B4(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_1B4_5 : 2;                                  // 0x01B4(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bCookedWidgetTree : 1;                             // 0x01B4(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1B5[0xB];                                      // 0x01B5(0x000B)(Fixing Size After Last Property [ Dumper-7 ])
	EWidgetTickFrequency                          TickFrequency;                                     // 0x01C0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1C1[0x7];                                      // 0x01C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UInputComponent*                        InputComponent;                                    // 0x01C8(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FAnimationEventBinding>         AnimationCallbacks;                                // 0x01D0(0x0010)(ZeroConstructor, Transient, DuplicateTransient, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_1E0[0x50];                                     // 0x01E0(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool AddToPlayerScreen(int32 ZOrder);
	void AddToViewport(int32 ZOrder);
	void BindToAnimationEvent(class UWidgetAnimation* Animation, TDelegate<void()> Delegate, EWidgetAnimationEvent AnimationEvent, class FName UserTag);
	void BindToAnimationFinished(class UWidgetAnimation* Animation, TDelegate<void()> Delegate);
	void BindToAnimationStarted(class UWidgetAnimation* Animation, TDelegate<void()> Delegate);
	void CancelLatentActions();
	void Construct();
	void Destruct();
	bool IsAnimationPlayingForward(const class UWidgetAnimation* InAnimation);
	void ListenForInputAction(class FName ActionName, EInputEvent EventType, bool bConsume, TDelegate<void()> Callback);
	void OnAddedToFocusPath(const struct FFocusEvent& InFocusEvent);
	struct FEventReply OnAnalogValueChanged(const struct FGeometry& MyGeometry, const struct FAnalogInputEvent& InAnalogInputEvent);
	void OnAnimationFinished(const class UWidgetAnimation* Animation);
	void OnAnimationStarted(const class UWidgetAnimation* Animation);
	void OnDragCancelled(const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation);
	void OnDragDetected(const struct FGeometry& MyGeometry, const struct FPointerEvent& PointerEvent, class UDragDropOperation** Operation);
	void OnDragEnter(const struct FGeometry& MyGeometry, const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation);
	void OnDragLeave(const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation);
	bool OnDragOver(const struct FGeometry& MyGeometry, const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation);
	bool OnDrop(const struct FGeometry& MyGeometry, const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation);
	void OnFocusLost(const struct FFocusEvent& InFocusEvent);
	struct FEventReply OnFocusReceived(const struct FGeometry& MyGeometry, const struct FFocusEvent& InFocusEvent);
	void OnInitialized();
	struct FEventReply OnKeyChar(const struct FGeometry& MyGeometry, const struct FCharacterEvent& InCharacterEvent);
	struct FEventReply OnKeyDown(const struct FGeometry& MyGeometry, const struct FKeyEvent& InKeyEvent);
	struct FEventReply OnKeyUp(const struct FGeometry& MyGeometry, const struct FKeyEvent& InKeyEvent);
	struct FEventReply OnMotionDetected(const struct FGeometry& MyGeometry, const struct FMotionEvent& InMotionEvent);
	struct FEventReply OnMouseButtonDoubleClick(const struct FGeometry& InMyGeometry, const struct FPointerEvent& InMouseEvent);
	struct FEventReply OnMouseButtonDown(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent);
	struct FEventReply OnMouseButtonUp(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent);
	void OnMouseCaptureLost();
	void OnMouseEnter(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent);
	void OnMouseLeave(const struct FPointerEvent& MouseEvent);
	struct FEventReply OnMouseMove(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent);
	struct FEventReply OnMouseWheel(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent);
	struct FEventReply OnPreviewKeyDown(const struct FGeometry& MyGeometry, const struct FKeyEvent& InKeyEvent);
	struct FEventReply OnPreviewMouseButtonDown(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent);
	void OnRemovedFromFocusPath(const struct FFocusEvent& InFocusEvent);
	struct FEventReply OnTouchEnded(const struct FGeometry& MyGeometry, const struct FPointerEvent& InTouchEvent);
	struct FEventReply OnTouchForceChanged(const struct FGeometry& MyGeometry, const struct FPointerEvent& InTouchEvent);
	struct FEventReply OnTouchGesture(const struct FGeometry& MyGeometry, const struct FPointerEvent& GestureEvent);
	struct FEventReply OnTouchMoved(const struct FGeometry& MyGeometry, const struct FPointerEvent& InTouchEvent);
	struct FEventReply OnTouchStarted(const struct FGeometry& MyGeometry, const struct FPointerEvent& InTouchEvent);
	float PauseAnimation(const class UWidgetAnimation* InAnimation);
	class UUMGSequencePlayer* PlayAnimation(class UWidgetAnimation* InAnimation, float StartAtTime, int32 NumLoopsToPlay, EUMGSequencePlayMode PlayMode, float PlaybackSpeed);
	class UUMGSequencePlayer* PlayAnimationForward(class UWidgetAnimation* InAnimation, float PlaybackSpeed);
	class UUMGSequencePlayer* PlayAnimationReverse(class UWidgetAnimation* InAnimation, float PlaybackSpeed);
	class UUMGSequencePlayer* PlayAnimationTimeRange(class UWidgetAnimation* InAnimation, float StartAtTime, float EndAtTime, int32 NumLoopsToPlay, EUMGSequencePlayMode PlayMode, float PlaybackSpeed);
	void PlaySound(class USoundBase* SoundToPlay);
	void PreConstruct(bool IsDesignTime);
	void RegisterInputComponent();
	void RemoveFromViewport();
	void ReverseAnimation(const class UWidgetAnimation* InAnimation);
	void SetAlignmentInViewport(const struct FVector2D& Alignment);
	void SetAnchorsInViewport(const struct FAnchors& Anchors);
	void SetColorAndOpacity(const struct FLinearColor& InColorAndOpacity);
	void SetDesiredSizeInViewport(const struct FVector2D& Size);
	void SetForegroundColor(const struct FSlateColor& InForegroundColor);
	void SetInputActionBlocking(bool bShouldBlock);
	void SetInputActionPriority(int32 NewPriority);
	void SetNumLoopsToPlay(const class UWidgetAnimation* InAnimation, int32 NumLoopsToPlay);
	void SetOwningPlayer(class APlayerController* LocalPlayerController);
	void SetPadding(const struct FMargin& InPadding);
	void SetPlaybackSpeed(const class UWidgetAnimation* InAnimation, float PlaybackSpeed);
	void SetPositionInViewport(const struct FVector2D& Position, bool bRemoveDPIScale);
	void StopAllAnimations();
	void StopAnimation(const class UWidgetAnimation* InAnimation);
	void StopAnimationsAndLatentActions();
	void StopListeningForAllInputActions();
	void StopListeningForInputAction(class FName ActionName, EInputEvent EventType);
	void Tick(const struct FGeometry& MyGeometry, float InDeltaTime);
	void UnbindAllFromAnimationFinished(class UWidgetAnimation* Animation);
	void UnbindAllFromAnimationStarted(class UWidgetAnimation* Animation);
	void UnbindFromAnimationFinished(class UWidgetAnimation* Animation, TDelegate<void()> Delegate);
	void UnbindFromAnimationStarted(class UWidgetAnimation* Animation, TDelegate<void()> Delegate);
	void UnregisterInputComponent();

	struct FVector2D GetAlignmentInViewport() const;
	struct FAnchors GetAnchorsInViewport() const;
	float GetAnimationCurrentTime(const class UWidgetAnimation* InAnimation) const;
	bool GetIsVisible() const;
	class APawn* GetOwningPlayerPawn() const;
	bool IsAnimationPlaying(const class UWidgetAnimation* InAnimation) const;
	bool IsAnyAnimationPlaying() const;
	bool IsInteractable() const;
	bool IsInViewport() const;
	bool IsListeningForInputAction(class FName ActionName) const;
	bool IsPlayingAnimation() const;
	void OnPaint(struct FPaintContext& Context) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"UserWidget">();
	}
	static class UUserWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UUserWidget>();
	}
};
static_assert(alignof(UUserWidget) == 0x000008, "Wrong alignment on UUserWidget");
static_assert(sizeof(UUserWidget) == 0x000230, "Wrong size on UUserWidget");
static_assert(offsetof(UUserWidget, ColorAndOpacity) == 0x000110, "Member 'UUserWidget::ColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UUserWidget, ColorAndOpacityDelegate) == 0x000120, "Member 'UUserWidget::ColorAndOpacityDelegate' has a wrong offset!");
static_assert(offsetof(UUserWidget, ForegroundColor) == 0x000130, "Member 'UUserWidget::ForegroundColor' has a wrong offset!");
static_assert(offsetof(UUserWidget, ForegroundColorDelegate) == 0x000158, "Member 'UUserWidget::ForegroundColorDelegate' has a wrong offset!");
static_assert(offsetof(UUserWidget, Padding) == 0x000168, "Member 'UUserWidget::Padding' has a wrong offset!");
static_assert(offsetof(UUserWidget, ActiveSequencePlayers) == 0x000178, "Member 'UUserWidget::ActiveSequencePlayers' has a wrong offset!");
static_assert(offsetof(UUserWidget, StoppedSequencePlayers) == 0x000188, "Member 'UUserWidget::StoppedSequencePlayers' has a wrong offset!");
static_assert(offsetof(UUserWidget, NamedSlotBindings) == 0x000198, "Member 'UUserWidget::NamedSlotBindings' has a wrong offset!");
static_assert(offsetof(UUserWidget, WidgetTree) == 0x0001A8, "Member 'UUserWidget::WidgetTree' has a wrong offset!");
static_assert(offsetof(UUserWidget, Priority) == 0x0001B0, "Member 'UUserWidget::Priority' has a wrong offset!");
static_assert(offsetof(UUserWidget, TickFrequency) == 0x0001C0, "Member 'UUserWidget::TickFrequency' has a wrong offset!");
static_assert(offsetof(UUserWidget, InputComponent) == 0x0001C8, "Member 'UUserWidget::InputComponent' has a wrong offset!");
static_assert(offsetof(UUserWidget, AnimationCallbacks) == 0x0001D0, "Member 'UUserWidget::AnimationCallbacks' has a wrong offset!");

// Class UMG.MovieScene2DTransformTrack
// 0x0000 (0x0080 - 0x0080)
class UMovieScene2DTransformTrack final : public UMovieScenePropertyTrack
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScene2DTransformTrack">();
	}
	static class UMovieScene2DTransformTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScene2DTransformTrack>();
	}
};
static_assert(alignof(UMovieScene2DTransformTrack) == 0x000008, "Wrong alignment on UMovieScene2DTransformTrack");
static_assert(sizeof(UMovieScene2DTransformTrack) == 0x000080, "Wrong size on UMovieScene2DTransformTrack");

// Class UMG.Button
// 0x0308 (0x0428 - 0x0120)
class UButton : public UContentWidget
{
public:
	class USlateWidgetStyleAsset*                 Style;                                             // 0x0120(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FButtonStyle                           WidgetStyle;                                       // 0x0128(0x0278)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	struct FLinearColor                           ColorAndOpacity;                                   // 0x03A0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           BackgroundColor;                                   // 0x03B0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EButtonClickMethod                            ClickMethod;                                       // 0x03C0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EButtonTouchMethod                            TouchMethod;                                       // 0x03C1(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EButtonPressMethod                            PressMethod;                                       // 0x03C2(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsFocusable;                                       // 0x03C3(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C4[0x4];                                      // 0x03C4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnClicked;                                         // 0x03C8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnPressed;                                         // 0x03D8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnReleased;                                        // 0x03E8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnHovered;                                         // 0x03F8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnUnhovered;                                       // 0x0408(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_418[0x10];                                     // 0x0418(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetBackgroundColor(const struct FLinearColor& InBackgroundColor);
	void SetClickMethod(EButtonClickMethod InClickMethod);
	void SetColorAndOpacity(const struct FLinearColor& InColorAndOpacity);
	void SetPressMethod(EButtonPressMethod InPressMethod);
	void SetStyle(const struct FButtonStyle& InStyle);
	void SetTouchMethod(EButtonTouchMethod InTouchMethod);

	bool IsPressed() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Button">();
	}
	static class UButton* GetDefaultObj()
	{
		return GetDefaultObjImpl<UButton>();
	}
};
static_assert(alignof(UButton) == 0x000008, "Wrong alignment on UButton");
static_assert(sizeof(UButton) == 0x000428, "Wrong size on UButton");
static_assert(offsetof(UButton, Style) == 0x000120, "Member 'UButton::Style' has a wrong offset!");
static_assert(offsetof(UButton, WidgetStyle) == 0x000128, "Member 'UButton::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UButton, ColorAndOpacity) == 0x0003A0, "Member 'UButton::ColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UButton, BackgroundColor) == 0x0003B0, "Member 'UButton::BackgroundColor' has a wrong offset!");
static_assert(offsetof(UButton, ClickMethod) == 0x0003C0, "Member 'UButton::ClickMethod' has a wrong offset!");
static_assert(offsetof(UButton, TouchMethod) == 0x0003C1, "Member 'UButton::TouchMethod' has a wrong offset!");
static_assert(offsetof(UButton, PressMethod) == 0x0003C2, "Member 'UButton::PressMethod' has a wrong offset!");
static_assert(offsetof(UButton, IsFocusable) == 0x0003C3, "Member 'UButton::IsFocusable' has a wrong offset!");
static_assert(offsetof(UButton, OnClicked) == 0x0003C8, "Member 'UButton::OnClicked' has a wrong offset!");
static_assert(offsetof(UButton, OnPressed) == 0x0003D8, "Member 'UButton::OnPressed' has a wrong offset!");
static_assert(offsetof(UButton, OnReleased) == 0x0003E8, "Member 'UButton::OnReleased' has a wrong offset!");
static_assert(offsetof(UButton, OnHovered) == 0x0003F8, "Member 'UButton::OnHovered' has a wrong offset!");
static_assert(offsetof(UButton, OnUnhovered) == 0x000408, "Member 'UButton::OnUnhovered' has a wrong offset!");

// Class UMG.MenuAnchor
// 0x0040 (0x0160 - 0x0120)
class UMenuAnchor final : public UContentWidget
{
public:
	TSubclassOf<class UUserWidget>                MenuClass;                                         // 0x0120(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             OnGetMenuContentEvent;                             // 0x0128(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	EMenuPlacement                                Placement;                                         // 0x0138(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ShouldDeferPaintingAfterWindowContent;             // 0x0139(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          UseApplicationMenuStack;                           // 0x013A(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_13B[0x5];                                      // 0x013B(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnMenuOpenChanged;                                 // 0x0140(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_150[0x10];                                     // 0x0150(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void Close();
	void Open(bool bFocusMenu);
	void ToggleOpen(bool bFocusOnOpen);

	struct FVector2D GetMenuPosition() const;
	bool HasOpenSubMenus() const;
	bool IsOpen() const;
	bool ShouldOpenDueToClick() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MenuAnchor">();
	}
	static class UMenuAnchor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMenuAnchor>();
	}
};
static_assert(alignof(UMenuAnchor) == 0x000008, "Wrong alignment on UMenuAnchor");
static_assert(sizeof(UMenuAnchor) == 0x000160, "Wrong size on UMenuAnchor");
static_assert(offsetof(UMenuAnchor, MenuClass) == 0x000120, "Member 'UMenuAnchor::MenuClass' has a wrong offset!");
static_assert(offsetof(UMenuAnchor, OnGetMenuContentEvent) == 0x000128, "Member 'UMenuAnchor::OnGetMenuContentEvent' has a wrong offset!");
static_assert(offsetof(UMenuAnchor, Placement) == 0x000138, "Member 'UMenuAnchor::Placement' has a wrong offset!");
static_assert(offsetof(UMenuAnchor, ShouldDeferPaintingAfterWindowContent) == 0x000139, "Member 'UMenuAnchor::ShouldDeferPaintingAfterWindowContent' has a wrong offset!");
static_assert(offsetof(UMenuAnchor, UseApplicationMenuStack) == 0x00013A, "Member 'UMenuAnchor::UseApplicationMenuStack' has a wrong offset!");
static_assert(offsetof(UMenuAnchor, OnMenuOpenChanged) == 0x000140, "Member 'UMenuAnchor::OnMenuOpenChanged' has a wrong offset!");

// Class UMG.NamedSlot
// 0x0010 (0x0130 - 0x0120)
class UNamedSlot final : public UContentWidget
{
public:
	uint8                                         Pad_120[0x10];                                     // 0x0120(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class UMG.Slider
// 0x03E8 (0x04F0 - 0x0108)
class USlider : public UWidget
{
public:
	float                                         Value;                                             // 0x0108(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ValueDelegate;                                     // 0x010C(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_11C[0x4];                                      // 0x011C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSliderStyle                           WidgetStyle;                                       // 0x0120(0x0340)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	EOrientation                                  Orientation;                                       // 0x0460(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_461[0x3];                                      // 0x0461(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FLinearColor                           SliderBarColor;                                    // 0x0464(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           SliderHandleColor;                                 // 0x0474(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IndentHandle;                                      // 0x0484(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          Locked;                                            // 0x0485(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          MouseUsesStep;                                     // 0x0486(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          RequiresControllerLock;                            // 0x0487(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StepSize;                                          // 0x0488(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsFocusable;                                       // 0x048C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_48D[0x3];                                      // 0x048D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnMouseCaptureBegin;                               // 0x0490(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnMouseCaptureEnd;                                 // 0x04A0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnControllerCaptureBegin;                          // 0x04B0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnControllerCaptureEnd;                            // 0x04C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnValueChanged;                                    // 0x04D0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_4E0[0x10];                                     // 0x04E0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetIndentHandle(bool InValue);
	void SetLocked(bool InValue);
	void SetSliderBarColor(const struct FLinearColor& InValue);
	void SetSliderHandleColor(const struct FLinearColor& InValue);
	void SetStepSize(float InValue);
	void SetValue(float InValue);

	float GetValue() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Slider">();
	}
	static class USlider* GetDefaultObj()
	{
		return GetDefaultObjImpl<USlider>();
	}
};
static_assert(alignof(USlider) == 0x000008, "Wrong alignment on USlider");
static_assert(sizeof(USlider) == 0x0004F0, "Wrong size on USlider");
static_assert(offsetof(USlider, Value) == 0x000108, "Member 'USlider::Value' has a wrong offset!");
static_assert(offsetof(USlider, ValueDelegate) == 0x00010C, "Member 'USlider::ValueDelegate' has a wrong offset!");
static_assert(offsetof(USlider, WidgetStyle) == 0x000120, "Member 'USlider::WidgetStyle' has a wrong offset!");
static_assert(offsetof(USlider, Orientation) == 0x000460, "Member 'USlider::Orientation' has a wrong offset!");
static_assert(offsetof(USlider, SliderBarColor) == 0x000464, "Member 'USlider::SliderBarColor' has a wrong offset!");
static_assert(offsetof(USlider, SliderHandleColor) == 0x000474, "Member 'USlider::SliderHandleColor' has a wrong offset!");
static_assert(offsetof(USlider, IndentHandle) == 0x000484, "Member 'USlider::IndentHandle' has a wrong offset!");
static_assert(offsetof(USlider, Locked) == 0x000485, "Member 'USlider::Locked' has a wrong offset!");
static_assert(offsetof(USlider, MouseUsesStep) == 0x000486, "Member 'USlider::MouseUsesStep' has a wrong offset!");
static_assert(offsetof(USlider, RequiresControllerLock) == 0x000487, "Member 'USlider::RequiresControllerLock' has a wrong offset!");
static_assert(offsetof(USlider, StepSize) == 0x000488, "Member 'USlider::StepSize' has a wrong offset!");
static_assert(offsetof(USlider, IsFocusable) == 0x00048C, "Member 'USlider::IsFocusable' has a wrong offset!");
static_assert(offsetof(USlider, OnMouseCaptureBegin) == 0x000490, "Member 'USlider::OnMouseCaptureBegin' has a wrong offset!");
static_assert(offsetof(USlider, OnMouseCaptureEnd) == 0x0004A0, "Member 'USlider::OnMouseCaptureEnd' has a wrong offset!");
static_assert(offsetof(USlider, OnControllerCaptureBegin) == 0x0004B0, "Member 'USlider::OnControllerCaptureBegin' has a wrong offset!");
static_assert(offsetof(USlider, OnControllerCaptureEnd) == 0x0004C0, "Member 'USlider::OnControllerCaptureEnd' has a wrong offset!");
static_assert(offsetof(USlider, OnValueChanged) == 0x0004D0, "Member 'USlider::OnValueChanged' has a wrong offset!");

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

// Class UMG.Border
// 0x0150 (0x0270 - 0x0120)
class UBorder : public UContentWidget
{
public:
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0120(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0121(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bShowEffectWhenDisabled : 1;                       // 0x0122(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_123[0x1];                                      // 0x0123(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FLinearColor                           ContentColorAndOpacity;                            // 0x0124(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ContentColorAndOpacityDelegate;                    // 0x0134(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FMargin                                Padding;                                           // 0x0144(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_154[0x4];                                      // 0x0154(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateBrush                            Background;                                        // 0x0158(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	TDelegate<void()>                             BackgroundDelegate;                                // 0x01E0(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           BrushColor;                                        // 0x01F0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             BrushColorDelegate;                                // 0x0200(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              DesiredSizeScale;                                  // 0x0210(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFlipForRightToLeftFlowDirection;                  // 0x0218(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_219[0x3];                                      // 0x0219(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(const struct FGeometry& MyGeometry, struct FPointerEvent& MouseEvent)> OnMouseButtonDownEvent;                            // 0x021C(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(const struct FGeometry& MyGeometry, struct FPointerEvent& MouseEvent)> OnMouseButtonUpEvent;                              // 0x022C(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(const struct FGeometry& MyGeometry, struct FPointerEvent& MouseEvent)> OnMouseMoveEvent;                                  // 0x023C(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	TDelegate<void(const struct FGeometry& MyGeometry, struct FPointerEvent& MouseEvent)> OnMouseDoubleClickEvent;                           // 0x024C(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_25C[0x14];                                     // 0x025C(0x0014)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UMaterialInstanceDynamic* GetDynamicMaterial();
	void SetBrush(const struct FSlateBrush& InBrush);
	void SetBrushColor(const struct FLinearColor& InBrushColor);
	void SetBrushFromAsset(class USlateBrushAsset* Asset);
	void SetBrushFromMaterial(class UMaterialInterface* Material);
	void SetBrushFromTexture(class UTexture2D* Texture);
	void SetContentColorAndOpacity(const struct FLinearColor& InContentColorAndOpacity);
	void SetDesiredSizeScale(const struct FVector2D& InScale);
	void SetHorizontalAlignment(EHorizontalAlignment InHorizontalAlignment);
	void SetPadding(const struct FMargin& InPadding);
	void SetVerticalAlignment(EVerticalAlignment InVerticalAlignment);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Border">();
	}
	static class UBorder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBorder>();
	}
};
static_assert(alignof(UBorder) == 0x000008, "Wrong alignment on UBorder");
static_assert(sizeof(UBorder) == 0x000270, "Wrong size on UBorder");
static_assert(offsetof(UBorder, HorizontalAlignment) == 0x000120, "Member 'UBorder::HorizontalAlignment' has a wrong offset!");
static_assert(offsetof(UBorder, VerticalAlignment) == 0x000121, "Member 'UBorder::VerticalAlignment' has a wrong offset!");
static_assert(offsetof(UBorder, ContentColorAndOpacity) == 0x000124, "Member 'UBorder::ContentColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UBorder, ContentColorAndOpacityDelegate) == 0x000134, "Member 'UBorder::ContentColorAndOpacityDelegate' has a wrong offset!");
static_assert(offsetof(UBorder, Padding) == 0x000144, "Member 'UBorder::Padding' has a wrong offset!");
static_assert(offsetof(UBorder, Background) == 0x000158, "Member 'UBorder::Background' has a wrong offset!");
static_assert(offsetof(UBorder, BackgroundDelegate) == 0x0001E0, "Member 'UBorder::BackgroundDelegate' has a wrong offset!");
static_assert(offsetof(UBorder, BrushColor) == 0x0001F0, "Member 'UBorder::BrushColor' has a wrong offset!");
static_assert(offsetof(UBorder, BrushColorDelegate) == 0x000200, "Member 'UBorder::BrushColorDelegate' has a wrong offset!");
static_assert(offsetof(UBorder, DesiredSizeScale) == 0x000210, "Member 'UBorder::DesiredSizeScale' has a wrong offset!");
static_assert(offsetof(UBorder, bFlipForRightToLeftFlowDirection) == 0x000218, "Member 'UBorder::bFlipForRightToLeftFlowDirection' has a wrong offset!");
static_assert(offsetof(UBorder, OnMouseButtonDownEvent) == 0x00021C, "Member 'UBorder::OnMouseButtonDownEvent' has a wrong offset!");
static_assert(offsetof(UBorder, OnMouseButtonUpEvent) == 0x00022C, "Member 'UBorder::OnMouseButtonUpEvent' has a wrong offset!");
static_assert(offsetof(UBorder, OnMouseMoveEvent) == 0x00023C, "Member 'UBorder::OnMouseMoveEvent' has a wrong offset!");
static_assert(offsetof(UBorder, OnMouseDoubleClickEvent) == 0x00024C, "Member 'UBorder::OnMouseDoubleClickEvent' has a wrong offset!");

// Class UMG.TextLayoutWidget
// 0x0020 (0x0128 - 0x0108)
class UTextLayoutWidget : public UWidget
{
public:
	struct FShapedTextOptions                     ShapedTextOptions;                                 // 0x0108(0x0003)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, Protected, NativeAccessSpecifierProtected)
	ETextJustify                                  Justification;                                     // 0x010B(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ETextWrappingPolicy                           WrappingPolicy;                                    // 0x010C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         AutoWrapText : 1;                                  // 0x010D(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_10E[0x2];                                      // 0x010E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         WrapTextAt;                                        // 0x0110(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FMargin                                Margin;                                            // 0x0114(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, NativeAccessSpecifierProtected)
	float                                         LineHeightPercentage;                              // 0x0124(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextLayoutWidget">();
	}
	static class UTextLayoutWidget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextLayoutWidget>();
	}
};
static_assert(alignof(UTextLayoutWidget) == 0x000008, "Wrong alignment on UTextLayoutWidget");
static_assert(sizeof(UTextLayoutWidget) == 0x000128, "Wrong size on UTextLayoutWidget");
static_assert(offsetof(UTextLayoutWidget, ShapedTextOptions) == 0x000108, "Member 'UTextLayoutWidget::ShapedTextOptions' has a wrong offset!");
static_assert(offsetof(UTextLayoutWidget, Justification) == 0x00010B, "Member 'UTextLayoutWidget::Justification' has a wrong offset!");
static_assert(offsetof(UTextLayoutWidget, WrappingPolicy) == 0x00010C, "Member 'UTextLayoutWidget::WrappingPolicy' has a wrong offset!");
static_assert(offsetof(UTextLayoutWidget, WrapTextAt) == 0x000110, "Member 'UTextLayoutWidget::WrapTextAt' has a wrong offset!");
static_assert(offsetof(UTextLayoutWidget, Margin) == 0x000114, "Member 'UTextLayoutWidget::Margin' has a wrong offset!");
static_assert(offsetof(UTextLayoutWidget, LineHeightPercentage) == 0x000124, "Member 'UTextLayoutWidget::LineHeightPercentage' has a wrong offset!");

// Class UMG.NativeWidgetHost
// 0x0010 (0x0118 - 0x0108)
class UNativeWidgetHost : public UWidget
{
public:
	uint8                                         Pad_108[0x10];                                     // 0x0108(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class UMG.TextBlock
// 0x0178 (0x02A0 - 0x0128)
class UTextBlock : public UTextLayoutWidget
{
public:
	class FText                                   Text;                                              // 0x0128(0x0018)(Edit, NativeAccessSpecifierPublic)
	TDelegate<void()>                             TextDelegate;                                      // 0x0140(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FSlateColor                            ColorAndOpacity;                                   // 0x0150(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ColorAndOpacityDelegate;                           // 0x0178(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FSlateFontInfo                         Font;                                              // 0x0188(0x0050)(Edit, BlueprintVisible, BlueprintReadOnly, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateBrush                            StrikeBrush;                                       // 0x01D8(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	struct FVector2D                              ShadowOffset;                                      // 0x0260(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ShadowColorAndOpacity;                             // 0x0268(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ShadowColorAndOpacityDelegate;                     // 0x0278(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	float                                         MinDesiredWidth;                                   // 0x0288(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bWrapWithInvalidationPanel;                        // 0x028C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAutoWrapText;                                     // 0x028D(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSimpleTextMode;                                   // 0x028E(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_28F[0x11];                                     // 0x028F(0x0011)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UMaterialInstanceDynamic* GetDynamicFontMaterial();
	class UMaterialInstanceDynamic* GetDynamicOutlineMaterial();
	void SetAutoWrapText(bool InAutoTextWrap);
	void SetColorAndOpacity(const struct FSlateColor& InColorAndOpacity);
	void SetFont(const struct FSlateFontInfo& InFontInfo);
	void SetJustification(ETextJustify InJustification);
	void SetMinDesiredWidth(float InMinDesiredWidth);
	void SetOpacity(float InOpacity);
	void SetShadowColorAndOpacity(const struct FLinearColor& InShadowColorAndOpacity);
	void SetShadowOffset(const struct FVector2D& InShadowOffset);
	void SetStrikeBrush(struct FSlateBrush* InStrikeBrush);
	void SetText(const class FText& InText);

	class FText GetText() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextBlock">();
	}
	static class UTextBlock* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextBlock>();
	}
};
static_assert(alignof(UTextBlock) == 0x000008, "Wrong alignment on UTextBlock");
static_assert(sizeof(UTextBlock) == 0x0002A0, "Wrong size on UTextBlock");
static_assert(offsetof(UTextBlock, Text) == 0x000128, "Member 'UTextBlock::Text' has a wrong offset!");
static_assert(offsetof(UTextBlock, TextDelegate) == 0x000140, "Member 'UTextBlock::TextDelegate' has a wrong offset!");
static_assert(offsetof(UTextBlock, ColorAndOpacity) == 0x000150, "Member 'UTextBlock::ColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UTextBlock, ColorAndOpacityDelegate) == 0x000178, "Member 'UTextBlock::ColorAndOpacityDelegate' has a wrong offset!");
static_assert(offsetof(UTextBlock, Font) == 0x000188, "Member 'UTextBlock::Font' has a wrong offset!");
static_assert(offsetof(UTextBlock, StrikeBrush) == 0x0001D8, "Member 'UTextBlock::StrikeBrush' has a wrong offset!");
static_assert(offsetof(UTextBlock, ShadowOffset) == 0x000260, "Member 'UTextBlock::ShadowOffset' has a wrong offset!");
static_assert(offsetof(UTextBlock, ShadowColorAndOpacity) == 0x000268, "Member 'UTextBlock::ShadowColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UTextBlock, ShadowColorAndOpacityDelegate) == 0x000278, "Member 'UTextBlock::ShadowColorAndOpacityDelegate' has a wrong offset!");
static_assert(offsetof(UTextBlock, MinDesiredWidth) == 0x000288, "Member 'UTextBlock::MinDesiredWidth' has a wrong offset!");
static_assert(offsetof(UTextBlock, bWrapWithInvalidationPanel) == 0x00028C, "Member 'UTextBlock::bWrapWithInvalidationPanel' has a wrong offset!");
static_assert(offsetof(UTextBlock, bAutoWrapText) == 0x00028D, "Member 'UTextBlock::bAutoWrapText' has a wrong offset!");
static_assert(offsetof(UTextBlock, bSimpleTextMode) == 0x00028E, "Member 'UTextBlock::bSimpleTextMode' has a wrong offset!");

// Class UMG.ScrollBox
// 0x0748 (0x0868 - 0x0120)
class UScrollBox : public UPanelWidget
{
public:
	struct FScrollBoxStyle                        WidgetStyle;                                       // 0x0120(0x0228)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	struct FScrollBarStyle                        WidgetBarStyle;                                    // 0x0348(0x04D0)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	class USlateWidgetStyleAsset*                 Style;                                             // 0x0818(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateWidgetStyleAsset*                 BarStyle;                                          // 0x0820(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EOrientation                                  Orientation;                                       // 0x0828(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESlateVisibility                              ScrollBarVisibility;                               // 0x0829(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EConsumeMouseWheel                            ConsumeMouseWheel;                                 // 0x082A(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_82B[0x1];                                      // 0x082B(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              ScrollbarThickness;                                // 0x082C(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          AlwaysShowScrollbar;                               // 0x0834(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          AllowOverscroll;                                   // 0x0835(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDescendantScrollDestination                  NavigationDestination;                             // 0x0836(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_837[0x1];                                      // 0x0837(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         NavigationScrollPadding;                           // 0x0838(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowRightClickDragScrolling;                     // 0x083C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_83D[0x3];                                      // 0x083D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnUserScrolled;                                    // 0x0840(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_850[0x18];                                     // 0x0850(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ScrollToEnd();
	void ScrollToStart();
	void ScrollWidgetIntoView(class UWidget* WidgetToFind, bool AnimateScroll, EDescendantScrollDestination ScrollDestination);
	void SetAllowOverscroll(bool NewAllowOverscroll);
	void SetAlwaysShowScrollbar(bool NewAlwaysShowScrollbar);
	void SetOrientation(EOrientation NewOrientation);
	void SetScrollbarThickness(const struct FVector2D& NewScrollbarThickness);
	void SetScrollBarVisibility(ESlateVisibility NewScrollBarVisibility);
	void SetScrollOffset(float NewScrollOffset);

	float GetScrollOffset() const;
	float GetViewOffsetFraction() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ScrollBox">();
	}
	static class UScrollBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UScrollBox>();
	}
};
static_assert(alignof(UScrollBox) == 0x000008, "Wrong alignment on UScrollBox");
static_assert(sizeof(UScrollBox) == 0x000868, "Wrong size on UScrollBox");
static_assert(offsetof(UScrollBox, WidgetStyle) == 0x000120, "Member 'UScrollBox::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UScrollBox, WidgetBarStyle) == 0x000348, "Member 'UScrollBox::WidgetBarStyle' has a wrong offset!");
static_assert(offsetof(UScrollBox, Style) == 0x000818, "Member 'UScrollBox::Style' has a wrong offset!");
static_assert(offsetof(UScrollBox, BarStyle) == 0x000820, "Member 'UScrollBox::BarStyle' has a wrong offset!");
static_assert(offsetof(UScrollBox, Orientation) == 0x000828, "Member 'UScrollBox::Orientation' has a wrong offset!");
static_assert(offsetof(UScrollBox, ScrollBarVisibility) == 0x000829, "Member 'UScrollBox::ScrollBarVisibility' has a wrong offset!");
static_assert(offsetof(UScrollBox, ConsumeMouseWheel) == 0x00082A, "Member 'UScrollBox::ConsumeMouseWheel' has a wrong offset!");
static_assert(offsetof(UScrollBox, ScrollbarThickness) == 0x00082C, "Member 'UScrollBox::ScrollbarThickness' has a wrong offset!");
static_assert(offsetof(UScrollBox, AlwaysShowScrollbar) == 0x000834, "Member 'UScrollBox::AlwaysShowScrollbar' has a wrong offset!");
static_assert(offsetof(UScrollBox, AllowOverscroll) == 0x000835, "Member 'UScrollBox::AllowOverscroll' has a wrong offset!");
static_assert(offsetof(UScrollBox, NavigationDestination) == 0x000836, "Member 'UScrollBox::NavigationDestination' has a wrong offset!");
static_assert(offsetof(UScrollBox, NavigationScrollPadding) == 0x000838, "Member 'UScrollBox::NavigationScrollPadding' has a wrong offset!");
static_assert(offsetof(UScrollBox, bAllowRightClickDragScrolling) == 0x00083C, "Member 'UScrollBox::bAllowRightClickDragScrolling' has a wrong offset!");
static_assert(offsetof(UScrollBox, OnUserScrolled) == 0x000840, "Member 'UScrollBox::OnUserScrolled' has a wrong offset!");

// Class UMG.PropertyBinding
// 0x0038 (0x0060 - 0x0028)
class UPropertyBinding : public UObject
{
public:
	TWeakObjectPtr<class UObject>                 SourceObject;                                      // 0x0028(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FDynamicPropertyPath                   SourcePath;                                        // 0x0030(0x0028)(NativeAccessSpecifierPublic)
	class FName                                   DestinationProperty;                               // 0x0058(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PropertyBinding">();
	}
	static class UPropertyBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPropertyBinding>();
	}
};
static_assert(alignof(UPropertyBinding) == 0x000008, "Wrong alignment on UPropertyBinding");
static_assert(sizeof(UPropertyBinding) == 0x000060, "Wrong size on UPropertyBinding");
static_assert(offsetof(UPropertyBinding, SourceObject) == 0x000028, "Member 'UPropertyBinding::SourceObject' has a wrong offset!");
static_assert(offsetof(UPropertyBinding, SourcePath) == 0x000030, "Member 'UPropertyBinding::SourcePath' has a wrong offset!");
static_assert(offsetof(UPropertyBinding, DestinationProperty) == 0x000058, "Member 'UPropertyBinding::DestinationProperty' has a wrong offset!");

// Class UMG.BoolBinding
// 0x0000 (0x0060 - 0x0060)
class UBoolBinding final : public UPropertyBinding
{
public:
	bool GetValue() const;

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

// Class UMG.Image
// 0x0108 (0x0210 - 0x0108)
class UImage : public UWidget
{
public:
	struct FSlateBrush                            Brush;                                             // 0x0108(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	TDelegate<void()>                             BrushDelegate;                                     // 0x0190(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           ColorAndOpacity;                                   // 0x01A0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ColorAndOpacityDelegate;                           // 0x01B0(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bFlipForRightToLeftFlowDirection;                  // 0x01C0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C1[0x3];                                      // 0x01C1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(const struct FGeometry& MyGeometry, struct FPointerEvent& MouseEvent)> OnMouseButtonDownEvent;                            // 0x01C4(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D4[0x3C];                                     // 0x01D4(0x003C)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UMaterialInstanceDynamic* GetDynamicMaterial();
	void SetBrush(const struct FSlateBrush& InBrush);
	void SetBrushFromAsset(class USlateBrushAsset* Asset);
	void SetBrushFromAtlasInterface(TScriptInterface<class ISlateTextureAtlasInterface> AtlasRegion, bool bMatchSize);
	void SetBrushFromMaterial(class UMaterialInterface* Material);
	void SetBrushFromSoftMaterial(TSoftObjectPtr<class UMaterialInterface> SoftMaterial);
	void SetBrushFromSoftTexture(TSoftObjectPtr<class UTexture2D> SoftTexture, bool bMatchSize);
	void SetBrushFromTexture(class UTexture2D* Texture, bool bMatchSize);
	void SetBrushFromTextureDynamic(class UTexture2DDynamic* Texture, bool bMatchSize);
	void SetBrushSize(const struct FVector2D& DesiredSize);
	void SetBrushTintColor(const struct FSlateColor& TintColor);
	void SetColorAndOpacity(const struct FLinearColor& InColorAndOpacity);
	void SetOpacity(float InOpacity);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Image">();
	}
	static class UImage* GetDefaultObj()
	{
		return GetDefaultObjImpl<UImage>();
	}
};
static_assert(alignof(UImage) == 0x000008, "Wrong alignment on UImage");
static_assert(sizeof(UImage) == 0x000210, "Wrong size on UImage");
static_assert(offsetof(UImage, Brush) == 0x000108, "Member 'UImage::Brush' has a wrong offset!");
static_assert(offsetof(UImage, BrushDelegate) == 0x000190, "Member 'UImage::BrushDelegate' has a wrong offset!");
static_assert(offsetof(UImage, ColorAndOpacity) == 0x0001A0, "Member 'UImage::ColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UImage, ColorAndOpacityDelegate) == 0x0001B0, "Member 'UImage::ColorAndOpacityDelegate' has a wrong offset!");
static_assert(offsetof(UImage, bFlipForRightToLeftFlowDirection) == 0x0001C0, "Member 'UImage::bFlipForRightToLeftFlowDirection' has a wrong offset!");
static_assert(offsetof(UImage, OnMouseButtonDownEvent) == 0x0001C4, "Member 'UImage::OnMouseButtonDownEvent' has a wrong offset!");

// Class UMG.ListViewBase
// 0x0108 (0x0210 - 0x0108)
class UListViewBase : public UWidget
{
public:
	TSubclassOf<class UUserWidget>                EntryWidgetClass;                                  // 0x0108(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	UMulticastDelegateProperty_                   BP_OnEntryGenerated;                               // 0x0110(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   BP_OnEntryReleased;                                // 0x0120(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	uint8                                         Pad_130[0xE0];                                     // 0x0130(0x00E0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void RegenerateAllEntries();
	void ScrollToBottom();
	void ScrollToTop();

	const TArray<class UUserWidget*> GetDisplayedEntryWidgets() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ListViewBase">();
	}
	static class UListViewBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UListViewBase>();
	}
};
static_assert(alignof(UListViewBase) == 0x000008, "Wrong alignment on UListViewBase");
static_assert(sizeof(UListViewBase) == 0x000210, "Wrong size on UListViewBase");
static_assert(offsetof(UListViewBase, EntryWidgetClass) == 0x000108, "Member 'UListViewBase::EntryWidgetClass' has a wrong offset!");
static_assert(offsetof(UListViewBase, BP_OnEntryGenerated) == 0x000110, "Member 'UListViewBase::BP_OnEntryGenerated' has a wrong offset!");
static_assert(offsetof(UListViewBase, BP_OnEntryReleased) == 0x000120, "Member 'UListViewBase::BP_OnEntryReleased' has a wrong offset!");

// Class UMG.CanvasPanel
// 0x0010 (0x0130 - 0x0120)
class UCanvasPanel final : public UPanelWidget
{
public:
	uint8                                         Pad_120[0x10];                                     // 0x0120(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UCanvasPanelSlot* AddChildToCanvas(class UWidget* Content);

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

// Class UMG.ListView
// 0x0128 (0x0338 - 0x0210)
class UListView : public UListViewBase
{
public:
	uint8                                         Pad_210[0xA8];                                     // 0x0210(0x00A8)(Fixing Size After Last Property [ Dumper-7 ])
	ESelectionMode                                SelectionMode;                                     // 0x02B8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EConsumeMouseWheel                            ConsumeMouseWheel;                                 // 0x02B9(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bClearSelectionOnClick;                            // 0x02BA(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsFocusable;                                      // 0x02BB(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         EntrySpacing;                                      // 0x02BC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bReturnFocusToSelection;                           // 0x02C0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2C1[0x7];                                      // 0x02C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UObject*>                        ListItems;                                         // 0x02C8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_2D8[0x10];                                     // 0x02D8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   BP_OnItemClicked;                                  // 0x02E8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   BP_OnItemDoubleClicked;                            // 0x02F8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   BP_OnItemIsHoveredChanged;                         // 0x0308(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   BP_OnItemSelectionChanged;                         // 0x0318(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   BP_OnItemScrolledIntoView;                         // 0x0328(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)

public:
	void AddItem(class UObject* Item);
	void BP_CancelScrollIntoView();
	void BP_ClearSelection();
	void BP_NavigateToItem(class UObject* Item);
	void BP_ScrollItemIntoView(class UObject* Item);
	void BP_SetItemSelection(class UObject* Item, bool bSelected);
	void BP_SetListItems(const TArray<class UObject*>& InListItems);
	void BP_SetSelectedItem(class UObject* Item);
	void ClearListItems();
	void NavigateToIndex(int32 Param_Index);
	void ScrollIndexIntoView(int32 Param_Index);
	void SetSelectedIndex(int32 Param_Index);
	void SetSelectionMode(ESelectionMode Param_SelectionMode);

	int32 BP_GetNumItemsSelected() const;
	class UObject* BP_GetSelectedItem() const;
	bool BP_GetSelectedItems(TArray<class UObject*>* Items) const;
	bool BP_IsItemVisible(class UObject* Item) const;
	int32 GetIndexForItem(class UObject* Item) const;
	class UObject* GetItemAt(int32 Param_Index) const;
	const TArray<class UObject*> GetListItems() const;
	int32 GetNumItems() const;
	bool IsRefreshPending() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ListView">();
	}
	static class UListView* GetDefaultObj()
	{
		return GetDefaultObjImpl<UListView>();
	}
};
static_assert(alignof(UListView) == 0x000008, "Wrong alignment on UListView");
static_assert(sizeof(UListView) == 0x000338, "Wrong size on UListView");
static_assert(offsetof(UListView, SelectionMode) == 0x0002B8, "Member 'UListView::SelectionMode' has a wrong offset!");
static_assert(offsetof(UListView, ConsumeMouseWheel) == 0x0002B9, "Member 'UListView::ConsumeMouseWheel' has a wrong offset!");
static_assert(offsetof(UListView, bClearSelectionOnClick) == 0x0002BA, "Member 'UListView::bClearSelectionOnClick' has a wrong offset!");
static_assert(offsetof(UListView, bIsFocusable) == 0x0002BB, "Member 'UListView::bIsFocusable' has a wrong offset!");
static_assert(offsetof(UListView, EntrySpacing) == 0x0002BC, "Member 'UListView::EntrySpacing' has a wrong offset!");
static_assert(offsetof(UListView, bReturnFocusToSelection) == 0x0002C0, "Member 'UListView::bReturnFocusToSelection' has a wrong offset!");
static_assert(offsetof(UListView, ListItems) == 0x0002C8, "Member 'UListView::ListItems' has a wrong offset!");
static_assert(offsetof(UListView, BP_OnItemClicked) == 0x0002E8, "Member 'UListView::BP_OnItemClicked' has a wrong offset!");
static_assert(offsetof(UListView, BP_OnItemDoubleClicked) == 0x0002F8, "Member 'UListView::BP_OnItemDoubleClicked' has a wrong offset!");
static_assert(offsetof(UListView, BP_OnItemIsHoveredChanged) == 0x000308, "Member 'UListView::BP_OnItemIsHoveredChanged' has a wrong offset!");
static_assert(offsetof(UListView, BP_OnItemSelectionChanged) == 0x000318, "Member 'UListView::BP_OnItemSelectionChanged' has a wrong offset!");
static_assert(offsetof(UListView, BP_OnItemScrolledIntoView) == 0x000328, "Member 'UListView::BP_OnItemScrolledIntoView' has a wrong offset!");

// Class UMG.NativeUserListEntry
// 0x0000 (0x0028 - 0x0028)
class INativeUserListEntry : public IInterface
{
public:
	class UListViewBase* GetOwningListView() const;
	bool IsListItemExpanded() const;
	bool IsListItemSelected() const;

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

// Class UMG.UserListEntry
// 0x0000 (0x0028 - 0x0028)
class IUserListEntry : public INativeUserListEntry
{
public:
	void BP_OnEntryReleased();
	void BP_OnItemExpansionChanged(bool bIsExpanded);
	void BP_OnItemSelectionChanged(bool bIsSelected);

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

// Class UMG.PanelSlot
// 0x0010 (0x0038 - 0x0028)
class UPanelSlot : public UVisual
{
public:
	class UPanelWidget*                           Parent;                                            // 0x0028(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidget*                                Content;                                           // 0x0030(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PanelSlot">();
	}
	static class UPanelSlot* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPanelSlot>();
	}
};
static_assert(alignof(UPanelSlot) == 0x000008, "Wrong alignment on UPanelSlot");
static_assert(sizeof(UPanelSlot) == 0x000038, "Wrong size on UPanelSlot");
static_assert(offsetof(UPanelSlot, Parent) == 0x000028, "Member 'UPanelSlot::Parent' has a wrong offset!");
static_assert(offsetof(UPanelSlot, Content) == 0x000030, "Member 'UPanelSlot::Content' has a wrong offset!");

// Class UMG.DynamicEntryBox
// 0x00D0 (0x01D8 - 0x0108)
class UDynamicEntryBox : public UWidget
{
public:
	EDynamicBoxType                               EntryBoxType;                                      // 0x0108(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_109[0x3];                                      // 0x0109(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              EntrySpacing;                                      // 0x010C(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_114[0x4];                                      // 0x0114(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FVector2D>                      SpacingPattern;                                    // 0x0118(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	struct FSlateChildSize                        EntrySizeRule;                                     // 0x0128(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, NativeAccessSpecifierProtected)
	EHorizontalAlignment                          EntryHorizontalAlignment;                          // 0x0130(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EVerticalAlignment                            EntryVerticalAlignment;                            // 0x0131(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_132[0x2];                                      // 0x0132(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MaxElementSize;                                    // 0x0134(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_138[0x10];                                     // 0x0138(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UUserWidget>                EntryWidgetClass;                                  // 0x0148(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_150[0x88];                                     // 0x0150(0x0088)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UUserWidget* BP_CreateEntry();
	class UUserWidget* BP_CreateEntryOfClass(TSubclassOf<class UUserWidget> EntryClass);
	void RemoveEntry(class UUserWidget* EntryWidget);
	void Reset(bool bDeleteWidgets);
	void SetEntrySpacing(const struct FVector2D& InEntrySpacing);

	const TArray<class UUserWidget*> GetAllEntries() const;
	int32 GetNumEntries() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DynamicEntryBox">();
	}
	static class UDynamicEntryBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDynamicEntryBox>();
	}
};
static_assert(alignof(UDynamicEntryBox) == 0x000008, "Wrong alignment on UDynamicEntryBox");
static_assert(sizeof(UDynamicEntryBox) == 0x0001D8, "Wrong size on UDynamicEntryBox");
static_assert(offsetof(UDynamicEntryBox, EntryBoxType) == 0x000108, "Member 'UDynamicEntryBox::EntryBoxType' has a wrong offset!");
static_assert(offsetof(UDynamicEntryBox, EntrySpacing) == 0x00010C, "Member 'UDynamicEntryBox::EntrySpacing' has a wrong offset!");
static_assert(offsetof(UDynamicEntryBox, SpacingPattern) == 0x000118, "Member 'UDynamicEntryBox::SpacingPattern' has a wrong offset!");
static_assert(offsetof(UDynamicEntryBox, EntrySizeRule) == 0x000128, "Member 'UDynamicEntryBox::EntrySizeRule' has a wrong offset!");
static_assert(offsetof(UDynamicEntryBox, EntryHorizontalAlignment) == 0x000130, "Member 'UDynamicEntryBox::EntryHorizontalAlignment' has a wrong offset!");
static_assert(offsetof(UDynamicEntryBox, EntryVerticalAlignment) == 0x000131, "Member 'UDynamicEntryBox::EntryVerticalAlignment' has a wrong offset!");
static_assert(offsetof(UDynamicEntryBox, MaxElementSize) == 0x000134, "Member 'UDynamicEntryBox::MaxElementSize' has a wrong offset!");
static_assert(offsetof(UDynamicEntryBox, EntryWidgetClass) == 0x000148, "Member 'UDynamicEntryBox::EntryWidgetClass' has a wrong offset!");

// Class UMG.TileView
// 0x0020 (0x0358 - 0x0338)
class UTileView : public UListView
{
public:
	float                                         EntryHeight;                                       // 0x0338(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         EntryWidth;                                        // 0x033C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EListItemAlignment                            TileAlignment;                                     // 0x0340(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bWrapHorizontalNavigation;                         // 0x0341(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_342[0x16];                                     // 0x0342(0x0016)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetEntryHeight(float NewHeight);
	void SetEntryWidth(float NewWidth);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TileView">();
	}
	static class UTileView* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTileView>();
	}
};
static_assert(alignof(UTileView) == 0x000008, "Wrong alignment on UTileView");
static_assert(sizeof(UTileView) == 0x000358, "Wrong size on UTileView");
static_assert(offsetof(UTileView, EntryHeight) == 0x000338, "Member 'UTileView::EntryHeight' has a wrong offset!");
static_assert(offsetof(UTileView, EntryWidth) == 0x00033C, "Member 'UTileView::EntryWidth' has a wrong offset!");
static_assert(offsetof(UTileView, TileAlignment) == 0x000340, "Member 'UTileView::TileAlignment' has a wrong offset!");
static_assert(offsetof(UTileView, bWrapHorizontalNavigation) == 0x000341, "Member 'UTileView::bWrapHorizontalNavigation' has a wrong offset!");

// Class UMG.ComboBoxString
// 0x0BB8 (0x0CC0 - 0x0108)
class UComboBoxString final : public UWidget
{
public:
	TArray<class FString>                         DefaultOptions;                                    // 0x0108(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	class FString                                 SelectedOption;                                    // 0x0118(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FComboBoxStyle                         WidgetStyle;                                       // 0x0128(0x03D8)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	struct FTableRowStyle                         ItemStyle;                                         // 0x0500(0x06B8)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	struct FMargin                                ContentPadding;                                    // 0x0BB8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         MaxListHeight;                                     // 0x0BC8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          HasDownArrow;                                      // 0x0BCC(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          EnableGamepadNavigationMode;                       // 0x0BCD(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BCE[0x2];                                      // 0x0BCE(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateFontInfo                         Font;                                              // 0x0BD0(0x0050)(Edit, BlueprintVisible, BlueprintReadOnly, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateColor                            ForegroundColor;                                   // 0x0C20(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	bool                                          bIsFocusable;                                      // 0x0C48(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C49[0x3];                                      // 0x0C49(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(const class FString& Item)>    OnGenerateWidgetEvent;                             // 0x0C4C(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_C5C[0x4];                                      // 0x0C5C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnSelectionChanged;                                // 0x0C60(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnOpening;                                         // 0x0C70(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_C80[0x40];                                     // 0x0C80(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddOption(const class FString& Option);
	void ClearOptions();
	void ClearSelection();
	void OnOpeningEvent__DelegateSignature();
	void OnSelectionChangedEvent__DelegateSignature(const class FString& SelectedItem, ESelectInfo SelectionType);
	void RefreshOptions();
	bool RemoveOption(const class FString& Option);
	void SetSelectedOption(const class FString& Option);

	int32 FindOptionIndex(const class FString& Option) const;
	class FString GetOptionAtIndex(int32 Param_Index) const;
	int32 GetOptionCount() const;
	class FString GetSelectedOption() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ComboBoxString">();
	}
	static class UComboBoxString* GetDefaultObj()
	{
		return GetDefaultObjImpl<UComboBoxString>();
	}
};
static_assert(alignof(UComboBoxString) == 0x000008, "Wrong alignment on UComboBoxString");
static_assert(sizeof(UComboBoxString) == 0x000CC0, "Wrong size on UComboBoxString");
static_assert(offsetof(UComboBoxString, DefaultOptions) == 0x000108, "Member 'UComboBoxString::DefaultOptions' has a wrong offset!");
static_assert(offsetof(UComboBoxString, SelectedOption) == 0x000118, "Member 'UComboBoxString::SelectedOption' has a wrong offset!");
static_assert(offsetof(UComboBoxString, WidgetStyle) == 0x000128, "Member 'UComboBoxString::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UComboBoxString, ItemStyle) == 0x000500, "Member 'UComboBoxString::ItemStyle' has a wrong offset!");
static_assert(offsetof(UComboBoxString, ContentPadding) == 0x000BB8, "Member 'UComboBoxString::ContentPadding' has a wrong offset!");
static_assert(offsetof(UComboBoxString, MaxListHeight) == 0x000BC8, "Member 'UComboBoxString::MaxListHeight' has a wrong offset!");
static_assert(offsetof(UComboBoxString, HasDownArrow) == 0x000BCC, "Member 'UComboBoxString::HasDownArrow' has a wrong offset!");
static_assert(offsetof(UComboBoxString, EnableGamepadNavigationMode) == 0x000BCD, "Member 'UComboBoxString::EnableGamepadNavigationMode' has a wrong offset!");
static_assert(offsetof(UComboBoxString, Font) == 0x000BD0, "Member 'UComboBoxString::Font' has a wrong offset!");
static_assert(offsetof(UComboBoxString, ForegroundColor) == 0x000C20, "Member 'UComboBoxString::ForegroundColor' has a wrong offset!");
static_assert(offsetof(UComboBoxString, bIsFocusable) == 0x000C48, "Member 'UComboBoxString::bIsFocusable' has a wrong offset!");
static_assert(offsetof(UComboBoxString, OnGenerateWidgetEvent) == 0x000C4C, "Member 'UComboBoxString::OnGenerateWidgetEvent' has a wrong offset!");
static_assert(offsetof(UComboBoxString, OnSelectionChanged) == 0x000C60, "Member 'UComboBoxString::OnSelectionChanged' has a wrong offset!");
static_assert(offsetof(UComboBoxString, OnOpening) == 0x000C70, "Member 'UComboBoxString::OnOpening' has a wrong offset!");

// Class UMG.TreeView
// 0x0058 (0x0390 - 0x0338)
class UTreeView : public UListView
{
public:
	uint8                                         Pad_338[0x10];                                     // 0x0338(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(class UObject* Item, TArray<class UObject*>* Children)> BP_OnGetItemChildren;                              // 0x0348(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPrivate)
	UMulticastDelegateProperty_                   BP_OnItemExpansionChanged;                         // 0x0358(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	uint8                                         Pad_368[0x28];                                     // 0x0368(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void CollapseAll();
	void ExpandAll();
	void SetItemExpansion(class UObject* Item, bool bExpandItem);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TreeView">();
	}
	static class UTreeView* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTreeView>();
	}
};
static_assert(alignof(UTreeView) == 0x000008, "Wrong alignment on UTreeView");
static_assert(sizeof(UTreeView) == 0x000390, "Wrong size on UTreeView");
static_assert(offsetof(UTreeView, BP_OnGetItemChildren) == 0x000348, "Member 'UTreeView::BP_OnGetItemChildren' has a wrong offset!");
static_assert(offsetof(UTreeView, BP_OnItemExpansionChanged) == 0x000358, "Member 'UTreeView::BP_OnItemExpansionChanged' has a wrong offset!");

// Class UMG.MovieSceneMarginTrack
// 0x0000 (0x0080 - 0x0080)
class UMovieSceneMarginTrack final : public UMovieScenePropertyTrack
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneMarginTrack">();
	}
	static class UMovieSceneMarginTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneMarginTrack>();
	}
};
static_assert(alignof(UMovieSceneMarginTrack) == 0x000008, "Wrong alignment on UMovieSceneMarginTrack");
static_assert(sizeof(UMovieSceneMarginTrack) == 0x000080, "Wrong size on UMovieSceneMarginTrack");

// Class UMG.WidgetSwitcher
// 0x0018 (0x0138 - 0x0120)
class UWidgetSwitcher : public UPanelWidget
{
public:
	int32                                         ActiveWidgetIndex;                                 // 0x0120(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_124[0x14];                                     // 0x0124(0x0014)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetActiveWidget(class UWidget* Widget);
	void SetActiveWidgetIndex(int32 Param_Index);

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

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

// Class UMG.AsyncTaskDownloadImage
// 0x0020 (0x0050 - 0x0030)
class UAsyncTaskDownloadImage final : public UBlueprintAsyncActionBase
{
public:
	UMulticastDelegateProperty_                   OnSuccess;                                         // 0x0030(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnFail;                                            // 0x0040(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAsyncTaskDownloadImage* DownloadImage(const class FString& URL);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncTaskDownloadImage">();
	}
	static class UAsyncTaskDownloadImage* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncTaskDownloadImage>();
	}
};
static_assert(alignof(UAsyncTaskDownloadImage) == 0x000008, "Wrong alignment on UAsyncTaskDownloadImage");
static_assert(sizeof(UAsyncTaskDownloadImage) == 0x000050, "Wrong size on UAsyncTaskDownloadImage");
static_assert(offsetof(UAsyncTaskDownloadImage, OnSuccess) == 0x000030, "Member 'UAsyncTaskDownloadImage::OnSuccess' has a wrong offset!");
static_assert(offsetof(UAsyncTaskDownloadImage, OnFail) == 0x000040, "Member 'UAsyncTaskDownloadImage::OnFail' has a wrong offset!");

// Class UMG.BackgroundBlur
// 0x00B8 (0x01D8 - 0x0120)
class UBackgroundBlur final : public UContentWidget
{
public:
	struct FMargin                                Padding;                                           // 0x0120(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0130(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0131(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bApplyAlphaToBlur;                                 // 0x0132(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_133[0x1];                                      // 0x0133(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         BlurStrength;                                      // 0x0134(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bOverrideAutoRadiusCalculation;                    // 0x0138(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_139[0x3];                                      // 0x0139(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         BlurRadius;                                        // 0x013C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateBrush                            LowQualityFallbackBrush;                           // 0x0140(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C8[0x10];                                     // 0x01C8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetApplyAlphaToBlur(bool bInApplyAlphaToBlur);
	void SetBlurRadius(int32 InBlurRadius);
	void SetBlurStrength(float InStrength);
	void SetHorizontalAlignment(EHorizontalAlignment InHorizontalAlignment);
	void SetLowQualityFallbackBrush(const struct FSlateBrush& InBrush);
	void SetPadding(const struct FMargin& InPadding);
	void SetVerticalAlignment(EVerticalAlignment InVerticalAlignment);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BackgroundBlur">();
	}
	static class UBackgroundBlur* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBackgroundBlur>();
	}
};
static_assert(alignof(UBackgroundBlur) == 0x000008, "Wrong alignment on UBackgroundBlur");
static_assert(sizeof(UBackgroundBlur) == 0x0001D8, "Wrong size on UBackgroundBlur");
static_assert(offsetof(UBackgroundBlur, Padding) == 0x000120, "Member 'UBackgroundBlur::Padding' has a wrong offset!");
static_assert(offsetof(UBackgroundBlur, HorizontalAlignment) == 0x000130, "Member 'UBackgroundBlur::HorizontalAlignment' has a wrong offset!");
static_assert(offsetof(UBackgroundBlur, VerticalAlignment) == 0x000131, "Member 'UBackgroundBlur::VerticalAlignment' has a wrong offset!");
static_assert(offsetof(UBackgroundBlur, bApplyAlphaToBlur) == 0x000132, "Member 'UBackgroundBlur::bApplyAlphaToBlur' has a wrong offset!");
static_assert(offsetof(UBackgroundBlur, BlurStrength) == 0x000134, "Member 'UBackgroundBlur::BlurStrength' has a wrong offset!");
static_assert(offsetof(UBackgroundBlur, bOverrideAutoRadiusCalculation) == 0x000138, "Member 'UBackgroundBlur::bOverrideAutoRadiusCalculation' has a wrong offset!");
static_assert(offsetof(UBackgroundBlur, BlurRadius) == 0x00013C, "Member 'UBackgroundBlur::BlurRadius' has a wrong offset!");
static_assert(offsetof(UBackgroundBlur, LowQualityFallbackBrush) == 0x000140, "Member 'UBackgroundBlur::LowQualityFallbackBrush' has a wrong offset!");

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

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

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

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

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

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

// Class UMG.BrushBinding
// 0x0008 (0x0068 - 0x0060)
class UBrushBinding final : public UPropertyBinding
{
public:
	uint8                                         Pad_60[0x8];                                       // 0x0060(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	struct FSlateBrush GetValue() const;

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

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

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

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

// Class UMG.CanvasPanelSlot
// 0x0038 (0x0070 - 0x0038)
class UCanvasPanelSlot final : public UPanelSlot
{
public:
	struct FAnchorData                            LayoutData;                                        // 0x0038(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bAutoSize;                                         // 0x0060(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_61[0x3];                                       // 0x0061(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ZOrder;                                            // 0x0064(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_68[0x8];                                       // 0x0068(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetAlignment(const struct FVector2D& InAlignment);
	void SetAnchors(const struct FAnchors& InAnchors);
	void SetAutoSize(bool InbAutoSize);
	void SetLayout(const struct FAnchorData& InLayoutData);
	void SetMaximum(const struct FVector2D& InMaximumAnchors);
	void SetMinimum(const struct FVector2D& InMinimumAnchors);
	void SetOffsets(const struct FMargin& InOffset);
	void SetPosition(const struct FVector2D& InPosition);
	void SetSize(const struct FVector2D& InSize);
	void SetZOrder(int32 InZOrder);

	struct FVector2D GetAlignment() const;
	struct FAnchors GetAnchors() const;
	bool GetAutoSize() const;
	struct FAnchorData GetLayout() const;
	struct FMargin GetOffsets() const;
	struct FVector2D GetPosition() const;
	struct FVector2D GetSize() const;
	int32 GetZOrder() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CanvasPanelSlot">();
	}
	static class UCanvasPanelSlot* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCanvasPanelSlot>();
	}
};
static_assert(alignof(UCanvasPanelSlot) == 0x000008, "Wrong alignment on UCanvasPanelSlot");
static_assert(sizeof(UCanvasPanelSlot) == 0x000070, "Wrong size on UCanvasPanelSlot");
static_assert(offsetof(UCanvasPanelSlot, LayoutData) == 0x000038, "Member 'UCanvasPanelSlot::LayoutData' has a wrong offset!");
static_assert(offsetof(UCanvasPanelSlot, bAutoSize) == 0x000060, "Member 'UCanvasPanelSlot::bAutoSize' has a wrong offset!");
static_assert(offsetof(UCanvasPanelSlot, ZOrder) == 0x000064, "Member 'UCanvasPanelSlot::ZOrder' has a wrong offset!");

// Class UMG.CheckBox
// 0x0650 (0x0770 - 0x0120)
class UCheckBox final : public UContentWidget
{
public:
	ECheckBoxState                                CheckedState;                                      // 0x0120(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_121[0x3];                                      // 0x0121(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void()>                             CheckedStateDelegate;                              // 0x0124(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_134[0x4];                                      // 0x0134(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FCheckBoxStyle                         WidgetStyle;                                       // 0x0138(0x0580)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	class USlateWidgetStyleAsset*                 Style;                                             // 0x06B8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       UncheckedImage;                                    // 0x06C0(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       UncheckedHoveredImage;                             // 0x06C8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       UncheckedPressedImage;                             // 0x06D0(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       CheckedImage;                                      // 0x06D8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       CheckedHoveredImage;                               // 0x06E0(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       CheckedPressedImage;                               // 0x06E8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       UndeterminedImage;                                 // 0x06F0(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       UndeterminedHoveredImage;                          // 0x06F8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       UndeterminedPressedImage;                          // 0x0700(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0708(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_709[0x3];                                      // 0x0709(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMargin                                Padding;                                           // 0x070C(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_71C[0x4];                                      // 0x071C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateColor                            BorderBackgroundColor;                             // 0x0720(0x0028)(Deprecated, NativeAccessSpecifierPublic)
	bool                                          IsFocusable;                                       // 0x0748(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_749[0x7];                                      // 0x0749(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnCheckStateChanged;                               // 0x0750(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_760[0x10];                                     // 0x0760(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetCheckedState(ECheckBoxState InCheckedState);
	void SetIsChecked(bool InIsChecked);

	ECheckBoxState GetCheckedState() const;
	bool IsChecked() const;
	bool IsPressed() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CheckBox">();
	}
	static class UCheckBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCheckBox>();
	}
};
static_assert(alignof(UCheckBox) == 0x000008, "Wrong alignment on UCheckBox");
static_assert(sizeof(UCheckBox) == 0x000770, "Wrong size on UCheckBox");
static_assert(offsetof(UCheckBox, CheckedState) == 0x000120, "Member 'UCheckBox::CheckedState' has a wrong offset!");
static_assert(offsetof(UCheckBox, CheckedStateDelegate) == 0x000124, "Member 'UCheckBox::CheckedStateDelegate' has a wrong offset!");
static_assert(offsetof(UCheckBox, WidgetStyle) == 0x000138, "Member 'UCheckBox::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UCheckBox, Style) == 0x0006B8, "Member 'UCheckBox::Style' has a wrong offset!");
static_assert(offsetof(UCheckBox, UncheckedImage) == 0x0006C0, "Member 'UCheckBox::UncheckedImage' has a wrong offset!");
static_assert(offsetof(UCheckBox, UncheckedHoveredImage) == 0x0006C8, "Member 'UCheckBox::UncheckedHoveredImage' has a wrong offset!");
static_assert(offsetof(UCheckBox, UncheckedPressedImage) == 0x0006D0, "Member 'UCheckBox::UncheckedPressedImage' has a wrong offset!");
static_assert(offsetof(UCheckBox, CheckedImage) == 0x0006D8, "Member 'UCheckBox::CheckedImage' has a wrong offset!");
static_assert(offsetof(UCheckBox, CheckedHoveredImage) == 0x0006E0, "Member 'UCheckBox::CheckedHoveredImage' has a wrong offset!");
static_assert(offsetof(UCheckBox, CheckedPressedImage) == 0x0006E8, "Member 'UCheckBox::CheckedPressedImage' has a wrong offset!");
static_assert(offsetof(UCheckBox, UndeterminedImage) == 0x0006F0, "Member 'UCheckBox::UndeterminedImage' has a wrong offset!");
static_assert(offsetof(UCheckBox, UndeterminedHoveredImage) == 0x0006F8, "Member 'UCheckBox::UndeterminedHoveredImage' has a wrong offset!");
static_assert(offsetof(UCheckBox, UndeterminedPressedImage) == 0x000700, "Member 'UCheckBox::UndeterminedPressedImage' has a wrong offset!");
static_assert(offsetof(UCheckBox, HorizontalAlignment) == 0x000708, "Member 'UCheckBox::HorizontalAlignment' has a wrong offset!");
static_assert(offsetof(UCheckBox, Padding) == 0x00070C, "Member 'UCheckBox::Padding' has a wrong offset!");
static_assert(offsetof(UCheckBox, BorderBackgroundColor) == 0x000720, "Member 'UCheckBox::BorderBackgroundColor' has a wrong offset!");
static_assert(offsetof(UCheckBox, IsFocusable) == 0x000748, "Member 'UCheckBox::IsFocusable' has a wrong offset!");
static_assert(offsetof(UCheckBox, OnCheckStateChanged) == 0x000750, "Member 'UCheckBox::OnCheckStateChanged' has a wrong offset!");

// Class UMG.CheckedStateBinding
// 0x0008 (0x0068 - 0x0060)
class UCheckedStateBinding final : public UPropertyBinding
{
public:
	uint8                                         Pad_60[0x8];                                       // 0x0060(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	ECheckBoxState GetValue() const;

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

// Class UMG.CircularThrobber
// 0x00B8 (0x01C0 - 0x0108)
class UCircularThrobber final : public UWidget
{
public:
	int32                                         NumberOfPieces;                                    // 0x0108(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Period;                                            // 0x010C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x0110(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_114[0x4];                                      // 0x0114(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class USlateBrushAsset*                       PieceImage;                                        // 0x0118(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateBrush                            Image;                                             // 0x0120(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	bool                                          bEnableRadius;                                     // 0x01A8(0x0001)(Edit, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1A9[0x17];                                     // 0x01A9(0x0017)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetNumberOfPieces(int32 InNumberOfPieces);
	void SetPeriod(float InPeriod);
	void SetRadius(float InRadius);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CircularThrobber">();
	}
	static class UCircularThrobber* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCircularThrobber>();
	}
};
static_assert(alignof(UCircularThrobber) == 0x000008, "Wrong alignment on UCircularThrobber");
static_assert(sizeof(UCircularThrobber) == 0x0001C0, "Wrong size on UCircularThrobber");
static_assert(offsetof(UCircularThrobber, NumberOfPieces) == 0x000108, "Member 'UCircularThrobber::NumberOfPieces' has a wrong offset!");
static_assert(offsetof(UCircularThrobber, Period) == 0x00010C, "Member 'UCircularThrobber::Period' has a wrong offset!");
static_assert(offsetof(UCircularThrobber, Radius) == 0x000110, "Member 'UCircularThrobber::Radius' has a wrong offset!");
static_assert(offsetof(UCircularThrobber, PieceImage) == 0x000118, "Member 'UCircularThrobber::PieceImage' has a wrong offset!");
static_assert(offsetof(UCircularThrobber, Image) == 0x000120, "Member 'UCircularThrobber::Image' has a wrong offset!");
static_assert(offsetof(UCircularThrobber, bEnableRadius) == 0x0001A8, "Member 'UCircularThrobber::bEnableRadius' has a wrong offset!");

// Class UMG.ColorBinding
// 0x0008 (0x0068 - 0x0060)
class UColorBinding final : public UPropertyBinding
{
public:
	uint8                                         Pad_60[0x8];                                       // 0x0060(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	struct FLinearColor GetLinearValue() const;
	struct FSlateColor GetSlateValue() const;

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

// Class UMG.ComboBox
// 0x0038 (0x0140 - 0x0108)
class UComboBox final : public UWidget
{
public:
	TArray<class UObject*>                        Items;                                             // 0x0108(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	TDelegate<void(class UObject* Item)>          OnGenerateWidgetEvent;                             // 0x0118(0x0010)(Edit, ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bIsFocusable;                                      // 0x0128(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_129[0x17];                                     // 0x0129(0x0017)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ComboBox">();
	}
	static class UComboBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UComboBox>();
	}
};
static_assert(alignof(UComboBox) == 0x000008, "Wrong alignment on UComboBox");
static_assert(sizeof(UComboBox) == 0x000140, "Wrong size on UComboBox");
static_assert(offsetof(UComboBox, Items) == 0x000108, "Member 'UComboBox::Items' has a wrong offset!");
static_assert(offsetof(UComboBox, OnGenerateWidgetEvent) == 0x000118, "Member 'UComboBox::OnGenerateWidgetEvent' has a wrong offset!");
static_assert(offsetof(UComboBox, bIsFocusable) == 0x000128, "Member 'UComboBox::bIsFocusable' has a wrong offset!");

// Class UMG.DragDropOperation
// 0x0060 (0x0088 - 0x0028)
class UDragDropOperation final : public UObject
{
public:
	class FString                                 Tag;                                               // 0x0028(0x0010)(Edit, BlueprintVisible, ZeroConstructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UObject*                                Payload;                                           // 0x0038(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWidget*                                DefaultDragVisual;                                 // 0x0040(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDragPivot                                    Pivot;                                             // 0x0048(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x3];                                       // 0x0049(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              Offset;                                            // 0x004C(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_54[0x4];                                       // 0x0054(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnDrop;                                            // 0x0058(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnDragCancelled;                                   // 0x0068(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnDragged;                                         // 0x0078(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	void DragCancelled(const struct FPointerEvent& PointerEvent);
	void Dragged(const struct FPointerEvent& PointerEvent);
	void Drop(const struct FPointerEvent& PointerEvent);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DragDropOperation">();
	}
	static class UDragDropOperation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDragDropOperation>();
	}
};
static_assert(alignof(UDragDropOperation) == 0x000008, "Wrong alignment on UDragDropOperation");
static_assert(sizeof(UDragDropOperation) == 0x000088, "Wrong size on UDragDropOperation");
static_assert(offsetof(UDragDropOperation, Tag) == 0x000028, "Member 'UDragDropOperation::Tag' has a wrong offset!");
static_assert(offsetof(UDragDropOperation, Payload) == 0x000038, "Member 'UDragDropOperation::Payload' has a wrong offset!");
static_assert(offsetof(UDragDropOperation, DefaultDragVisual) == 0x000040, "Member 'UDragDropOperation::DefaultDragVisual' has a wrong offset!");
static_assert(offsetof(UDragDropOperation, Pivot) == 0x000048, "Member 'UDragDropOperation::Pivot' has a wrong offset!");
static_assert(offsetof(UDragDropOperation, Offset) == 0x00004C, "Member 'UDragDropOperation::Offset' has a wrong offset!");
static_assert(offsetof(UDragDropOperation, OnDrop) == 0x000058, "Member 'UDragDropOperation::OnDrop' has a wrong offset!");
static_assert(offsetof(UDragDropOperation, OnDragCancelled) == 0x000068, "Member 'UDragDropOperation::OnDragCancelled' has a wrong offset!");
static_assert(offsetof(UDragDropOperation, OnDragged) == 0x000078, "Member 'UDragDropOperation::OnDragged' has a wrong offset!");

// Class UMG.EditableText
// 0x0348 (0x0450 - 0x0108)
class UEditableText final : public UWidget
{
public:
	class FText                                   Text;                                              // 0x0108(0x0018)(Edit, NativeAccessSpecifierPublic)
	TDelegate<void()>                             TextDelegate;                                      // 0x0120(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	class FText                                   HintText;                                          // 0x0130(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	TDelegate<void()>                             HintTextDelegate;                                  // 0x0148(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FEditableTextStyle                     WidgetStyle;                                       // 0x0158(0x0218)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	class USlateWidgetStyleAsset*                 Style;                                             // 0x0370(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       BackgroundImageSelected;                           // 0x0378(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       BackgroundImageComposing;                          // 0x0380(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       CaretImage;                                        // 0x0388(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateFontInfo                         Font;                                              // 0x0390(0x0050)(Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateColor                            ColorAndOpacity;                                   // 0x03E0(0x0028)(Deprecated, NativeAccessSpecifierPublic)
	bool                                          IsReadOnly;                                        // 0x0408(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsPassword;                                        // 0x0409(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_40A[0x2];                                      // 0x040A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinimumDesiredWidth;                               // 0x040C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsCaretMovedWhenGainFocus;                         // 0x0410(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          SelectAllTextWhenFocused;                          // 0x0411(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          RevertTextOnEscape;                                // 0x0412(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ClearKeyboardFocusOnCommit;                        // 0x0413(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          SelectAllTextOnCommit;                             // 0x0414(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          AllowContextMenu;                                  // 0x0415(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVirtualKeyboardType                          KeyboardType;                                      // 0x0416(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVirtualKeyboardOptions                VirtualKeyboardOptions;                            // 0x0417(0x0001)(Edit, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	EVirtualKeyboardDismissAction                 VirtualKeyboardDismissAction;                      // 0x0418(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextJustify                                  Justification;                                     // 0x0419(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FShapedTextOptions                     ShapedTextOptions;                                 // 0x041A(0x0003)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	uint8                                         Pad_41D[0x3];                                      // 0x041D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnTextChanged;                                     // 0x0420(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnTextCommitted;                                   // 0x0430(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_440[0x10];                                     // 0x0440(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnEditableTextChangedEvent__DelegateSignature(const class FText& Param_Text);
	void OnEditableTextCommittedEvent__DelegateSignature(const class FText& Param_Text, ETextCommit CommitMethod);
	void SetHintText(const class FText& InHintText);
	void SetIsPassword(bool InbIsPassword);
	void SetIsReadOnly(bool InbIsReadyOnly);
	void SetText(const class FText& InText);

	class FText GetText() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EditableText">();
	}
	static class UEditableText* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEditableText>();
	}
};
static_assert(alignof(UEditableText) == 0x000008, "Wrong alignment on UEditableText");
static_assert(sizeof(UEditableText) == 0x000450, "Wrong size on UEditableText");
static_assert(offsetof(UEditableText, Text) == 0x000108, "Member 'UEditableText::Text' has a wrong offset!");
static_assert(offsetof(UEditableText, TextDelegate) == 0x000120, "Member 'UEditableText::TextDelegate' has a wrong offset!");
static_assert(offsetof(UEditableText, HintText) == 0x000130, "Member 'UEditableText::HintText' has a wrong offset!");
static_assert(offsetof(UEditableText, HintTextDelegate) == 0x000148, "Member 'UEditableText::HintTextDelegate' has a wrong offset!");
static_assert(offsetof(UEditableText, WidgetStyle) == 0x000158, "Member 'UEditableText::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UEditableText, Style) == 0x000370, "Member 'UEditableText::Style' has a wrong offset!");
static_assert(offsetof(UEditableText, BackgroundImageSelected) == 0x000378, "Member 'UEditableText::BackgroundImageSelected' has a wrong offset!");
static_assert(offsetof(UEditableText, BackgroundImageComposing) == 0x000380, "Member 'UEditableText::BackgroundImageComposing' has a wrong offset!");
static_assert(offsetof(UEditableText, CaretImage) == 0x000388, "Member 'UEditableText::CaretImage' has a wrong offset!");
static_assert(offsetof(UEditableText, Font) == 0x000390, "Member 'UEditableText::Font' has a wrong offset!");
static_assert(offsetof(UEditableText, ColorAndOpacity) == 0x0003E0, "Member 'UEditableText::ColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UEditableText, IsReadOnly) == 0x000408, "Member 'UEditableText::IsReadOnly' has a wrong offset!");
static_assert(offsetof(UEditableText, IsPassword) == 0x000409, "Member 'UEditableText::IsPassword' has a wrong offset!");
static_assert(offsetof(UEditableText, MinimumDesiredWidth) == 0x00040C, "Member 'UEditableText::MinimumDesiredWidth' has a wrong offset!");
static_assert(offsetof(UEditableText, IsCaretMovedWhenGainFocus) == 0x000410, "Member 'UEditableText::IsCaretMovedWhenGainFocus' has a wrong offset!");
static_assert(offsetof(UEditableText, SelectAllTextWhenFocused) == 0x000411, "Member 'UEditableText::SelectAllTextWhenFocused' has a wrong offset!");
static_assert(offsetof(UEditableText, RevertTextOnEscape) == 0x000412, "Member 'UEditableText::RevertTextOnEscape' has a wrong offset!");
static_assert(offsetof(UEditableText, ClearKeyboardFocusOnCommit) == 0x000413, "Member 'UEditableText::ClearKeyboardFocusOnCommit' has a wrong offset!");
static_assert(offsetof(UEditableText, SelectAllTextOnCommit) == 0x000414, "Member 'UEditableText::SelectAllTextOnCommit' has a wrong offset!");
static_assert(offsetof(UEditableText, AllowContextMenu) == 0x000415, "Member 'UEditableText::AllowContextMenu' has a wrong offset!");
static_assert(offsetof(UEditableText, KeyboardType) == 0x000416, "Member 'UEditableText::KeyboardType' has a wrong offset!");
static_assert(offsetof(UEditableText, VirtualKeyboardOptions) == 0x000417, "Member 'UEditableText::VirtualKeyboardOptions' has a wrong offset!");
static_assert(offsetof(UEditableText, VirtualKeyboardDismissAction) == 0x000418, "Member 'UEditableText::VirtualKeyboardDismissAction' has a wrong offset!");
static_assert(offsetof(UEditableText, Justification) == 0x000419, "Member 'UEditableText::Justification' has a wrong offset!");
static_assert(offsetof(UEditableText, ShapedTextOptions) == 0x00041A, "Member 'UEditableText::ShapedTextOptions' has a wrong offset!");
static_assert(offsetof(UEditableText, OnTextChanged) == 0x000420, "Member 'UEditableText::OnTextChanged' has a wrong offset!");
static_assert(offsetof(UEditableText, OnTextCommitted) == 0x000430, "Member 'UEditableText::OnTextCommitted' has a wrong offset!");

// Class UMG.EditableTextBox
// 0x0920 (0x0A28 - 0x0108)
class UEditableTextBox final : public UWidget
{
public:
	class FText                                   Text;                                              // 0x0108(0x0018)(Edit, NativeAccessSpecifierPublic)
	TDelegate<void()>                             TextDelegate;                                      // 0x0120(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FEditableTextBoxStyle                  WidgetStyle;                                       // 0x0130(0x07F0)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	class USlateWidgetStyleAsset*                 Style;                                             // 0x0920(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FText                                   HintText;                                          // 0x0928(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	TDelegate<void()>                             HintTextDelegate;                                  // 0x0940(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FSlateFontInfo                         Font;                                              // 0x0950(0x0050)(Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ForegroundColor;                                   // 0x09A0(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           BackgroundColor;                                   // 0x09B0(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ReadOnlyForegroundColor;                           // 0x09C0(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsReadOnly;                                        // 0x09D0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsPassword;                                        // 0x09D1(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9D2[0x2];                                      // 0x09D2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinimumDesiredWidth;                               // 0x09D4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMargin                                Padding;                                           // 0x09D8(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          IsCaretMovedWhenGainFocus;                         // 0x09E8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          SelectAllTextWhenFocused;                          // 0x09E9(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          RevertTextOnEscape;                                // 0x09EA(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ClearKeyboardFocusOnCommit;                        // 0x09EB(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          SelectAllTextOnCommit;                             // 0x09EC(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          AllowContextMenu;                                  // 0x09ED(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVirtualKeyboardType                          KeyboardType;                                      // 0x09EE(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVirtualKeyboardOptions                VirtualKeyboardOptions;                            // 0x09EF(0x0001)(Edit, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	EVirtualKeyboardDismissAction                 VirtualKeyboardDismissAction;                      // 0x09F0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextJustify                                  Justification;                                     // 0x09F1(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FShapedTextOptions                     ShapedTextOptions;                                 // 0x09F2(0x0003)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	uint8                                         Pad_9F5[0x3];                                      // 0x09F5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnTextChanged;                                     // 0x09F8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnTextCommitted;                                   // 0x0A08(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_A18[0x10];                                     // 0x0A18(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ClearError();
	void OnEditableTextBoxChangedEvent__DelegateSignature(const class FText& Param_Text);
	void OnEditableTextBoxCommittedEvent__DelegateSignature(const class FText& Param_Text, ETextCommit CommitMethod);
	void SetError(const class FText& InError);
	void SetHintText(const class FText& InText);
	void SetIsPassword(bool bIsPassword);
	void SetIsReadOnly(bool bReadOnly);
	void SetText(const class FText& InText);

	class FText GetText() const;
	bool HasError() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EditableTextBox">();
	}
	static class UEditableTextBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEditableTextBox>();
	}
};
static_assert(alignof(UEditableTextBox) == 0x000008, "Wrong alignment on UEditableTextBox");
static_assert(sizeof(UEditableTextBox) == 0x000A28, "Wrong size on UEditableTextBox");
static_assert(offsetof(UEditableTextBox, Text) == 0x000108, "Member 'UEditableTextBox::Text' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, TextDelegate) == 0x000120, "Member 'UEditableTextBox::TextDelegate' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, WidgetStyle) == 0x000130, "Member 'UEditableTextBox::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, Style) == 0x000920, "Member 'UEditableTextBox::Style' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, HintText) == 0x000928, "Member 'UEditableTextBox::HintText' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, HintTextDelegate) == 0x000940, "Member 'UEditableTextBox::HintTextDelegate' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, Font) == 0x000950, "Member 'UEditableTextBox::Font' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, ForegroundColor) == 0x0009A0, "Member 'UEditableTextBox::ForegroundColor' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, BackgroundColor) == 0x0009B0, "Member 'UEditableTextBox::BackgroundColor' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, ReadOnlyForegroundColor) == 0x0009C0, "Member 'UEditableTextBox::ReadOnlyForegroundColor' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, IsReadOnly) == 0x0009D0, "Member 'UEditableTextBox::IsReadOnly' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, IsPassword) == 0x0009D1, "Member 'UEditableTextBox::IsPassword' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, MinimumDesiredWidth) == 0x0009D4, "Member 'UEditableTextBox::MinimumDesiredWidth' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, Padding) == 0x0009D8, "Member 'UEditableTextBox::Padding' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, IsCaretMovedWhenGainFocus) == 0x0009E8, "Member 'UEditableTextBox::IsCaretMovedWhenGainFocus' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, SelectAllTextWhenFocused) == 0x0009E9, "Member 'UEditableTextBox::SelectAllTextWhenFocused' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, RevertTextOnEscape) == 0x0009EA, "Member 'UEditableTextBox::RevertTextOnEscape' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, ClearKeyboardFocusOnCommit) == 0x0009EB, "Member 'UEditableTextBox::ClearKeyboardFocusOnCommit' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, SelectAllTextOnCommit) == 0x0009EC, "Member 'UEditableTextBox::SelectAllTextOnCommit' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, AllowContextMenu) == 0x0009ED, "Member 'UEditableTextBox::AllowContextMenu' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, KeyboardType) == 0x0009EE, "Member 'UEditableTextBox::KeyboardType' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, VirtualKeyboardOptions) == 0x0009EF, "Member 'UEditableTextBox::VirtualKeyboardOptions' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, VirtualKeyboardDismissAction) == 0x0009F0, "Member 'UEditableTextBox::VirtualKeyboardDismissAction' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, Justification) == 0x0009F1, "Member 'UEditableTextBox::Justification' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, ShapedTextOptions) == 0x0009F2, "Member 'UEditableTextBox::ShapedTextOptions' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, OnTextChanged) == 0x0009F8, "Member 'UEditableTextBox::OnTextChanged' has a wrong offset!");
static_assert(offsetof(UEditableTextBox, OnTextCommitted) == 0x000A08, "Member 'UEditableTextBox::OnTextCommitted' has a wrong offset!");

// Class UMG.ExpandableArea
// 0x0230 (0x0338 - 0x0108)
class UExpandableArea final : public UWidget
{
public:
	uint8                                         Pad_108[0x8];                                      // 0x0108(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpandableAreaStyle                   Style;                                             // 0x0110(0x0120)(Edit, NativeAccessSpecifierPublic)
	struct FSlateBrush                            BorderBrush;                                       // 0x0230(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	struct FSlateColor                            BorderColor;                                       // 0x02B8(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	bool                                          bIsExpanded;                                       // 0x02E0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2E1[0x3];                                      // 0x02E1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MaxHeight;                                         // 0x02E4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMargin                                HeaderPadding;                                     // 0x02E8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FMargin                                AreaPadding;                                       // 0x02F8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnExpansionChanged;                                // 0x0308(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	class UWidget*                                HeaderContent;                                     // 0x0318(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UWidget*                                BodyContent;                                       // 0x0320(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_328[0x10];                                     // 0x0328(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetIsExpanded(bool IsExpanded);
	void SetIsExpanded_Animated(bool IsExpanded);

	bool GetIsExpanded() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ExpandableArea">();
	}
	static class UExpandableArea* GetDefaultObj()
	{
		return GetDefaultObjImpl<UExpandableArea>();
	}
};
static_assert(alignof(UExpandableArea) == 0x000008, "Wrong alignment on UExpandableArea");
static_assert(sizeof(UExpandableArea) == 0x000338, "Wrong size on UExpandableArea");
static_assert(offsetof(UExpandableArea, Style) == 0x000110, "Member 'UExpandableArea::Style' has a wrong offset!");
static_assert(offsetof(UExpandableArea, BorderBrush) == 0x000230, "Member 'UExpandableArea::BorderBrush' has a wrong offset!");
static_assert(offsetof(UExpandableArea, BorderColor) == 0x0002B8, "Member 'UExpandableArea::BorderColor' has a wrong offset!");
static_assert(offsetof(UExpandableArea, bIsExpanded) == 0x0002E0, "Member 'UExpandableArea::bIsExpanded' has a wrong offset!");
static_assert(offsetof(UExpandableArea, MaxHeight) == 0x0002E4, "Member 'UExpandableArea::MaxHeight' has a wrong offset!");
static_assert(offsetof(UExpandableArea, HeaderPadding) == 0x0002E8, "Member 'UExpandableArea::HeaderPadding' has a wrong offset!");
static_assert(offsetof(UExpandableArea, AreaPadding) == 0x0002F8, "Member 'UExpandableArea::AreaPadding' has a wrong offset!");
static_assert(offsetof(UExpandableArea, OnExpansionChanged) == 0x000308, "Member 'UExpandableArea::OnExpansionChanged' has a wrong offset!");
static_assert(offsetof(UExpandableArea, HeaderContent) == 0x000318, "Member 'UExpandableArea::HeaderContent' has a wrong offset!");
static_assert(offsetof(UExpandableArea, BodyContent) == 0x000320, "Member 'UExpandableArea::BodyContent' has a wrong offset!");

// Class UMG.FloatBinding
// 0x0000 (0x0060 - 0x0060)
class UFloatBinding final : public UPropertyBinding
{
public:
	float GetValue() const;

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

// Class UMG.GridPanel
// 0x0030 (0x0150 - 0x0120)
class UGridPanel final : public UPanelWidget
{
public:
	TArray<float>                                 ColumnFill;                                        // 0x0120(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<float>                                 RowFill;                                           // 0x0130(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_140[0x10];                                     // 0x0140(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UGridSlot* AddChildToGrid(class UWidget* Content);
	void SetColumnFill(int32 ColumnIndex, float Coefficient);
	void SetRowFill(int32 ColumnIndex, float Coefficient);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GridPanel">();
	}
	static class UGridPanel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGridPanel>();
	}
};
static_assert(alignof(UGridPanel) == 0x000008, "Wrong alignment on UGridPanel");
static_assert(sizeof(UGridPanel) == 0x000150, "Wrong size on UGridPanel");
static_assert(offsetof(UGridPanel, ColumnFill) == 0x000120, "Member 'UGridPanel::ColumnFill' has a wrong offset!");
static_assert(offsetof(UGridPanel, RowFill) == 0x000130, "Member 'UGridPanel::RowFill' has a wrong offset!");

// Class UMG.GridSlot
// 0x0038 (0x0070 - 0x0038)
class UGridSlot final : public UPanelSlot
{
public:
	struct FMargin                                Padding;                                           // 0x0038(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0048(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0049(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4A[0x2];                                       // 0x004A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         Row;                                               // 0x004C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         RowSpan;                                           // 0x0050(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Column;                                            // 0x0054(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ColumnSpan;                                        // 0x0058(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Layer;                                             // 0x005C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              Nudge;                                             // 0x0060(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_68[0x8];                                       // 0x0068(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetColumn(int32 InColumn);
	void SetColumnSpan(int32 InColumnSpan);
	void SetHorizontalAlignment(EHorizontalAlignment InHorizontalAlignment);
	void SetLayer(int32 InLayer);
	void SetPadding(const struct FMargin& InPadding);
	void SetRow(int32 InRow);
	void SetRowSpan(int32 InRowSpan);
	void SetVerticalAlignment(EVerticalAlignment InVerticalAlignment);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GridSlot">();
	}
	static class UGridSlot* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGridSlot>();
	}
};
static_assert(alignof(UGridSlot) == 0x000008, "Wrong alignment on UGridSlot");
static_assert(sizeof(UGridSlot) == 0x000070, "Wrong size on UGridSlot");
static_assert(offsetof(UGridSlot, Padding) == 0x000038, "Member 'UGridSlot::Padding' has a wrong offset!");
static_assert(offsetof(UGridSlot, HorizontalAlignment) == 0x000048, "Member 'UGridSlot::HorizontalAlignment' has a wrong offset!");
static_assert(offsetof(UGridSlot, VerticalAlignment) == 0x000049, "Member 'UGridSlot::VerticalAlignment' has a wrong offset!");
static_assert(offsetof(UGridSlot, Row) == 0x00004C, "Member 'UGridSlot::Row' has a wrong offset!");
static_assert(offsetof(UGridSlot, RowSpan) == 0x000050, "Member 'UGridSlot::RowSpan' has a wrong offset!");
static_assert(offsetof(UGridSlot, Column) == 0x000054, "Member 'UGridSlot::Column' has a wrong offset!");
static_assert(offsetof(UGridSlot, ColumnSpan) == 0x000058, "Member 'UGridSlot::ColumnSpan' has a wrong offset!");
static_assert(offsetof(UGridSlot, Layer) == 0x00005C, "Member 'UGridSlot::Layer' has a wrong offset!");
static_assert(offsetof(UGridSlot, Nudge) == 0x000060, "Member 'UGridSlot::Nudge' has a wrong offset!");

// Class UMG.HorizontalBox
// 0x0010 (0x0130 - 0x0120)
class UHorizontalBox final : public UPanelWidget
{
public:
	uint8                                         Pad_120[0x10];                                     // 0x0120(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UHorizontalBoxSlot* AddChildToHorizontalBox(class UWidget* Content);

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

// Class UMG.HorizontalBoxSlot
// 0x0028 (0x0060 - 0x0038)
class UHorizontalBoxSlot final : public UPanelSlot
{
public:
	struct FMargin                                Padding;                                           // 0x0038(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FSlateChildSize                        Size;                                              // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0050(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0051(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_52[0xE];                                       // 0x0052(0x000E)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

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

// Class UMG.InputKeySelector
// 0x05E8 (0x06F0 - 0x0108)
class UInputKeySelector final : public UWidget
{
public:
	struct FButtonStyle                           WidgetStyle;                                       // 0x0108(0x0278)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	struct FTextBlockStyle                        TextStyle;                                         // 0x0380(0x0268)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	struct FInputChord                            SelectedKey;                                       // 0x05E8(0x0020)(BlueprintVisible, BlueprintReadOnly, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateFontInfo                         Font;                                              // 0x0608(0x0050)(Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMargin                                Margin;                                            // 0x0658(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           ColorAndOpacity;                                   // 0x0668(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FText                                   KeySelectionText;                                  // 0x0678(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	class FText                                   NoKeySpecifiedText;                                // 0x0690(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	bool                                          bAllowModifierKeys;                                // 0x06A8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowGamepadKeys;                                 // 0x06A9(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6AA[0x6];                                      // 0x06AA(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FKey>                           EscapeKeys;                                        // 0x06B0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnKeySelected;                                     // 0x06C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnIsSelectingKeyChanged;                           // 0x06D0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_6E0[0x10];                                     // 0x06E0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnIsSelectingKeyChanged__DelegateSignature();
	void OnKeySelected__DelegateSignature(const struct FInputChord& Param_SelectedKey);
	void SetAllowGamepadKeys(bool bInAllowGamepadKeys);
	void SetAllowModifierKeys(bool bInAllowModifierKeys);
	void SetEscapeKeys(const TArray<struct FKey>& InKeys);
	void SetKeySelectionText(const class FText& InKeySelectionText);
	void SetNoKeySpecifiedText(const class FText& InNoKeySpecifiedText);
	void SetSelectedKey(const struct FInputChord& InSelectedKey);
	void SetTextBlockVisibility(const ESlateVisibility InVisibility);

	bool GetIsSelectingKey() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputKeySelector">();
	}
	static class UInputKeySelector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputKeySelector>();
	}
};
static_assert(alignof(UInputKeySelector) == 0x000008, "Wrong alignment on UInputKeySelector");
static_assert(sizeof(UInputKeySelector) == 0x0006F0, "Wrong size on UInputKeySelector");
static_assert(offsetof(UInputKeySelector, WidgetStyle) == 0x000108, "Member 'UInputKeySelector::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, TextStyle) == 0x000380, "Member 'UInputKeySelector::TextStyle' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, SelectedKey) == 0x0005E8, "Member 'UInputKeySelector::SelectedKey' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, Font) == 0x000608, "Member 'UInputKeySelector::Font' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, Margin) == 0x000658, "Member 'UInputKeySelector::Margin' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, ColorAndOpacity) == 0x000668, "Member 'UInputKeySelector::ColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, KeySelectionText) == 0x000678, "Member 'UInputKeySelector::KeySelectionText' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, NoKeySpecifiedText) == 0x000690, "Member 'UInputKeySelector::NoKeySpecifiedText' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, bAllowModifierKeys) == 0x0006A8, "Member 'UInputKeySelector::bAllowModifierKeys' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, bAllowGamepadKeys) == 0x0006A9, "Member 'UInputKeySelector::bAllowGamepadKeys' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, EscapeKeys) == 0x0006B0, "Member 'UInputKeySelector::EscapeKeys' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, OnKeySelected) == 0x0006C0, "Member 'UInputKeySelector::OnKeySelected' has a wrong offset!");
static_assert(offsetof(UInputKeySelector, OnIsSelectingKeyChanged) == 0x0006D0, "Member 'UInputKeySelector::OnIsSelectingKeyChanged' has a wrong offset!");

// Class UMG.Int32Binding
// 0x0000 (0x0060 - 0x0060)
class UInt32Binding final : public UPropertyBinding
{
public:
	int32 GetValue() const;

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

// Class UMG.UserObjectListEntry
// 0x0000 (0x0028 - 0x0028)
class IUserObjectListEntry final : public IUserListEntry
{
public:
	void OnListItemObjectSet(class UObject* ListItemObject);

	class UObject* GetListItemObject() const;

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

// Class UMG.MouseCursorBinding
// 0x0000 (0x0060 - 0x0060)
class UMouseCursorBinding final : public UPropertyBinding
{
public:
	EMouseCursor GetValue() const;

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

// Class UMG.MovieScene2DTransformSection
// 0x0470 (0x0550 - 0x00E0)
class UMovieScene2DTransformSection final : public UMovieSceneSection
{
public:
	struct FMovieScene2DTransformMask             TransformMask;                                     // 0x00E0(0x0004)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_E4[0x4];                                       // 0x00E4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneFloatChannel                Translation[0x2];                                  // 0x00E8(0x00A0)(NativeAccessSpecifierPublic)
	struct FMovieSceneFloatChannel                Rotation;                                          // 0x0228(0x00A0)(NativeAccessSpecifierPublic)
	struct FMovieSceneFloatChannel                Scale[0x2];                                        // 0x02C8(0x00A0)(NativeAccessSpecifierPublic)
	struct FMovieSceneFloatChannel                Shear[0x2];                                        // 0x0408(0x00A0)(NativeAccessSpecifierPublic)
	uint8                                         Pad_548[0x8];                                      // 0x0548(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScene2DTransformSection">();
	}
	static class UMovieScene2DTransformSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScene2DTransformSection>();
	}
};
static_assert(alignof(UMovieScene2DTransformSection) == 0x000008, "Wrong alignment on UMovieScene2DTransformSection");
static_assert(sizeof(UMovieScene2DTransformSection) == 0x000550, "Wrong size on UMovieScene2DTransformSection");
static_assert(offsetof(UMovieScene2DTransformSection, TransformMask) == 0x0000E0, "Member 'UMovieScene2DTransformSection::TransformMask' has a wrong offset!");
static_assert(offsetof(UMovieScene2DTransformSection, Translation) == 0x0000E8, "Member 'UMovieScene2DTransformSection::Translation' has a wrong offset!");
static_assert(offsetof(UMovieScene2DTransformSection, Rotation) == 0x000228, "Member 'UMovieScene2DTransformSection::Rotation' has a wrong offset!");
static_assert(offsetof(UMovieScene2DTransformSection, Scale) == 0x0002C8, "Member 'UMovieScene2DTransformSection::Scale' has a wrong offset!");
static_assert(offsetof(UMovieScene2DTransformSection, Shear) == 0x000408, "Member 'UMovieScene2DTransformSection::Shear' has a wrong offset!");

// Class UMG.MovieSceneMarginSection
// 0x0280 (0x0360 - 0x00E0)
class UMovieSceneMarginSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneFloatChannel                TopCurve;                                          // 0x00E0(0x00A0)(NativeAccessSpecifierPublic)
	struct FMovieSceneFloatChannel                LeftCurve;                                         // 0x0180(0x00A0)(NativeAccessSpecifierPublic)
	struct FMovieSceneFloatChannel                RightCurve;                                        // 0x0220(0x00A0)(NativeAccessSpecifierPublic)
	struct FMovieSceneFloatChannel                BottomCurve;                                       // 0x02C0(0x00A0)(NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneMarginSection">();
	}
	static class UMovieSceneMarginSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneMarginSection>();
	}
};
static_assert(alignof(UMovieSceneMarginSection) == 0x000008, "Wrong alignment on UMovieSceneMarginSection");
static_assert(sizeof(UMovieSceneMarginSection) == 0x000360, "Wrong size on UMovieSceneMarginSection");
static_assert(offsetof(UMovieSceneMarginSection, TopCurve) == 0x0000E0, "Member 'UMovieSceneMarginSection::TopCurve' has a wrong offset!");
static_assert(offsetof(UMovieSceneMarginSection, LeftCurve) == 0x000180, "Member 'UMovieSceneMarginSection::LeftCurve' has a wrong offset!");
static_assert(offsetof(UMovieSceneMarginSection, RightCurve) == 0x000220, "Member 'UMovieSceneMarginSection::RightCurve' has a wrong offset!");
static_assert(offsetof(UMovieSceneMarginSection, BottomCurve) == 0x0002C0, "Member 'UMovieSceneMarginSection::BottomCurve' has a wrong offset!");

// Class UMG.MovieSceneWidgetMaterialTrack
// 0x0018 (0x0080 - 0x0068)
class UMovieSceneWidgetMaterialTrack final : public UMovieSceneMaterialTrack
{
public:
	TArray<class FName>                           BrushPropertyNamePath;                             // 0x0068(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	class FName                                   TrackName;                                         // 0x0078(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneWidgetMaterialTrack">();
	}
	static class UMovieSceneWidgetMaterialTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneWidgetMaterialTrack>();
	}
};
static_assert(alignof(UMovieSceneWidgetMaterialTrack) == 0x000008, "Wrong alignment on UMovieSceneWidgetMaterialTrack");
static_assert(sizeof(UMovieSceneWidgetMaterialTrack) == 0x000080, "Wrong size on UMovieSceneWidgetMaterialTrack");
static_assert(offsetof(UMovieSceneWidgetMaterialTrack, BrushPropertyNamePath) == 0x000068, "Member 'UMovieSceneWidgetMaterialTrack::BrushPropertyNamePath' has a wrong offset!");
static_assert(offsetof(UMovieSceneWidgetMaterialTrack, TrackName) == 0x000078, "Member 'UMovieSceneWidgetMaterialTrack::TrackName' has a wrong offset!");

// Class UMG.MultiLineEditableText
// 0x0338 (0x0460 - 0x0128)
class UMultiLineEditableText final : public UTextLayoutWidget
{
public:
	class FText                                   Text;                                              // 0x0128(0x0018)(Edit, NativeAccessSpecifierPublic)
	class FText                                   HintText;                                          // 0x0140(0x0018)(Edit, NativeAccessSpecifierPublic)
	TDelegate<void()>                             HintTextDelegate;                                  // 0x0158(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FTextBlockStyle                        WidgetStyle;                                       // 0x0168(0x0268)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	bool                                          bIsReadOnly;                                       // 0x03D0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3D1[0x7];                                      // 0x03D1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateFontInfo                         Font;                                              // 0x03D8(0x0050)(Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          SelectAllTextWhenFocused;                          // 0x0428(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ClearTextSelectionOnFocusLoss;                     // 0x0429(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          RevertTextOnEscape;                                // 0x042A(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ClearKeyboardFocusOnCommit;                        // 0x042B(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          AllowContextMenu;                                  // 0x042C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVirtualKeyboardOptions                VirtualKeyboardOptions;                            // 0x042D(0x0001)(Edit, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	EVirtualKeyboardDismissAction                 VirtualKeyboardDismissAction;                      // 0x042E(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_42F[0x1];                                      // 0x042F(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	UMulticastDelegateProperty_                   OnTextChanged;                                     // 0x0430(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnTextCommitted;                                   // 0x0440(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_450[0x10];                                     // 0x0450(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnMultiLineEditableTextChangedEvent__DelegateSignature(const class FText& Param_Text);
	void OnMultiLineEditableTextCommittedEvent__DelegateSignature(const class FText& Param_Text, ETextCommit CommitMethod);
	void SetIsReadOnly(bool bReadOnly);
	void SetText(const class FText& InText);

	class FText GetText() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MultiLineEditableText">();
	}
	static class UMultiLineEditableText* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMultiLineEditableText>();
	}
};
static_assert(alignof(UMultiLineEditableText) == 0x000008, "Wrong alignment on UMultiLineEditableText");
static_assert(sizeof(UMultiLineEditableText) == 0x000460, "Wrong size on UMultiLineEditableText");
static_assert(offsetof(UMultiLineEditableText, Text) == 0x000128, "Member 'UMultiLineEditableText::Text' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, HintText) == 0x000140, "Member 'UMultiLineEditableText::HintText' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, HintTextDelegate) == 0x000158, "Member 'UMultiLineEditableText::HintTextDelegate' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, WidgetStyle) == 0x000168, "Member 'UMultiLineEditableText::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, bIsReadOnly) == 0x0003D0, "Member 'UMultiLineEditableText::bIsReadOnly' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, Font) == 0x0003D8, "Member 'UMultiLineEditableText::Font' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, SelectAllTextWhenFocused) == 0x000428, "Member 'UMultiLineEditableText::SelectAllTextWhenFocused' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, ClearTextSelectionOnFocusLoss) == 0x000429, "Member 'UMultiLineEditableText::ClearTextSelectionOnFocusLoss' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, RevertTextOnEscape) == 0x00042A, "Member 'UMultiLineEditableText::RevertTextOnEscape' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, ClearKeyboardFocusOnCommit) == 0x00042B, "Member 'UMultiLineEditableText::ClearKeyboardFocusOnCommit' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, AllowContextMenu) == 0x00042C, "Member 'UMultiLineEditableText::AllowContextMenu' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, VirtualKeyboardOptions) == 0x00042D, "Member 'UMultiLineEditableText::VirtualKeyboardOptions' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, VirtualKeyboardDismissAction) == 0x00042E, "Member 'UMultiLineEditableText::VirtualKeyboardDismissAction' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, OnTextChanged) == 0x000430, "Member 'UMultiLineEditableText::OnTextChanged' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableText, OnTextCommitted) == 0x000440, "Member 'UMultiLineEditableText::OnTextCommitted' has a wrong offset!");

// Class UMG.MultiLineEditableTextBox
// 0x0B58 (0x0C80 - 0x0128)
class UMultiLineEditableTextBox final : public UTextLayoutWidget
{
public:
	class FText                                   Text;                                              // 0x0128(0x0018)(Edit, NativeAccessSpecifierPublic)
	class FText                                   HintText;                                          // 0x0140(0x0018)(Edit, NativeAccessSpecifierPublic)
	TDelegate<void()>                             HintTextDelegate;                                  // 0x0158(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FEditableTextBoxStyle                  WidgetStyle;                                       // 0x0168(0x07F0)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	struct FTextBlockStyle                        TextStyle;                                         // 0x0958(0x0268)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	bool                                          bIsReadOnly;                                       // 0x0BC0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          AllowContextMenu;                                  // 0x0BC1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVirtualKeyboardOptions                VirtualKeyboardOptions;                            // 0x0BC2(0x0001)(Edit, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	EVirtualKeyboardDismissAction                 VirtualKeyboardDismissAction;                      // 0x0BC3(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BC4[0x4];                                      // 0x0BC4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class USlateWidgetStyleAsset*                 Style;                                             // 0x0BC8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateFontInfo                         Font;                                              // 0x0BD0(0x0050)(Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ForegroundColor;                                   // 0x0C20(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           BackgroundColor;                                   // 0x0C30(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ReadOnlyForegroundColor;                           // 0x0C40(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnTextChanged;                                     // 0x0C50(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnTextCommitted;                                   // 0x0C60(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_C70[0x10];                                     // 0x0C70(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnMultiLineEditableTextBoxChangedEvent__DelegateSignature(const class FText& Param_Text);
	void OnMultiLineEditableTextBoxCommittedEvent__DelegateSignature(const class FText& Param_Text, ETextCommit CommitMethod);
	void SetError(const class FText& InError);
	void SetIsReadOnly(bool bReadOnly);
	void SetText(const class FText& InText);

	class FText GetText() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MultiLineEditableTextBox">();
	}
	static class UMultiLineEditableTextBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMultiLineEditableTextBox>();
	}
};
static_assert(alignof(UMultiLineEditableTextBox) == 0x000008, "Wrong alignment on UMultiLineEditableTextBox");
static_assert(sizeof(UMultiLineEditableTextBox) == 0x000C80, "Wrong size on UMultiLineEditableTextBox");
static_assert(offsetof(UMultiLineEditableTextBox, Text) == 0x000128, "Member 'UMultiLineEditableTextBox::Text' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, HintText) == 0x000140, "Member 'UMultiLineEditableTextBox::HintText' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, HintTextDelegate) == 0x000158, "Member 'UMultiLineEditableTextBox::HintTextDelegate' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, WidgetStyle) == 0x000168, "Member 'UMultiLineEditableTextBox::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, TextStyle) == 0x000958, "Member 'UMultiLineEditableTextBox::TextStyle' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, bIsReadOnly) == 0x000BC0, "Member 'UMultiLineEditableTextBox::bIsReadOnly' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, AllowContextMenu) == 0x000BC1, "Member 'UMultiLineEditableTextBox::AllowContextMenu' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, VirtualKeyboardOptions) == 0x000BC2, "Member 'UMultiLineEditableTextBox::VirtualKeyboardOptions' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, VirtualKeyboardDismissAction) == 0x000BC3, "Member 'UMultiLineEditableTextBox::VirtualKeyboardDismissAction' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, Style) == 0x000BC8, "Member 'UMultiLineEditableTextBox::Style' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, Font) == 0x000BD0, "Member 'UMultiLineEditableTextBox::Font' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, ForegroundColor) == 0x000C20, "Member 'UMultiLineEditableTextBox::ForegroundColor' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, BackgroundColor) == 0x000C30, "Member 'UMultiLineEditableTextBox::BackgroundColor' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, ReadOnlyForegroundColor) == 0x000C40, "Member 'UMultiLineEditableTextBox::ReadOnlyForegroundColor' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, OnTextChanged) == 0x000C50, "Member 'UMultiLineEditableTextBox::OnTextChanged' has a wrong offset!");
static_assert(offsetof(UMultiLineEditableTextBox, OnTextCommitted) == 0x000C60, "Member 'UMultiLineEditableTextBox::OnTextCommitted' has a wrong offset!");

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

// Class UMG.Overlay
// 0x0010 (0x0130 - 0x0120)
class UOverlay final : public UPanelWidget
{
public:
	uint8                                         Pad_120[0x10];                                     // 0x0120(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UOverlaySlot* AddChildToOverlay(class UWidget* Content);

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

// Class UMG.OverlaySlot
// 0x0020 (0x0058 - 0x0038)
class UOverlaySlot final : public UPanelSlot
{
public:
	uint8                                         Pad_38[0x8];                                       // 0x0038(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMargin                                Padding;                                           // 0x0040(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0050(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0051(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_52[0x6];                                       // 0x0052(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"OverlaySlot">();
	}
	static class UOverlaySlot* GetDefaultObj()
	{
		return GetDefaultObjImpl<UOverlaySlot>();
	}
};
static_assert(alignof(UOverlaySlot) == 0x000008, "Wrong alignment on UOverlaySlot");
static_assert(sizeof(UOverlaySlot) == 0x000058, "Wrong size on UOverlaySlot");
static_assert(offsetof(UOverlaySlot, Padding) == 0x000040, "Member 'UOverlaySlot::Padding' has a wrong offset!");
static_assert(offsetof(UOverlaySlot, HorizontalAlignment) == 0x000050, "Member 'UOverlaySlot::HorizontalAlignment' has a wrong offset!");
static_assert(offsetof(UOverlaySlot, VerticalAlignment) == 0x000051, "Member 'UOverlaySlot::VerticalAlignment' has a wrong offset!");

// Class UMG.ProgressBar
// 0x0210 (0x0318 - 0x0108)
class UProgressBar final : public UWidget
{
public:
	struct FProgressBarStyle                      WidgetStyle;                                       // 0x0108(0x01A0)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	class USlateWidgetStyleAsset*                 Style;                                             // 0x02A8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       BackgroundImage;                                   // 0x02B0(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       FillImage;                                         // 0x02B8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USlateBrushAsset*                       MarqueeImage;                                      // 0x02C0(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Percent;                                           // 0x02C8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EProgressBarFillType                          BarFillType;                                       // 0x02CC(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsMarquee;                                        // 0x02CD(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2CE[0x2];                                      // 0x02CE(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              BorderPadding;                                     // 0x02D0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             PercentDelegate;                                   // 0x02D8(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           FillColorAndOpacity;                               // 0x02E8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             FillColorAndOpacityDelegate;                       // 0x02F8(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_308[0x10];                                     // 0x0308(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetFillColorAndOpacity(const struct FLinearColor& InColor);
	void SetIsMarquee(bool InbIsMarquee);
	void SetPercent(float InPercent);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ProgressBar">();
	}
	static class UProgressBar* GetDefaultObj()
	{
		return GetDefaultObjImpl<UProgressBar>();
	}
};
static_assert(alignof(UProgressBar) == 0x000008, "Wrong alignment on UProgressBar");
static_assert(sizeof(UProgressBar) == 0x000318, "Wrong size on UProgressBar");
static_assert(offsetof(UProgressBar, WidgetStyle) == 0x000108, "Member 'UProgressBar::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UProgressBar, Style) == 0x0002A8, "Member 'UProgressBar::Style' has a wrong offset!");
static_assert(offsetof(UProgressBar, BackgroundImage) == 0x0002B0, "Member 'UProgressBar::BackgroundImage' has a wrong offset!");
static_assert(offsetof(UProgressBar, FillImage) == 0x0002B8, "Member 'UProgressBar::FillImage' has a wrong offset!");
static_assert(offsetof(UProgressBar, MarqueeImage) == 0x0002C0, "Member 'UProgressBar::MarqueeImage' has a wrong offset!");
static_assert(offsetof(UProgressBar, Percent) == 0x0002C8, "Member 'UProgressBar::Percent' has a wrong offset!");
static_assert(offsetof(UProgressBar, BarFillType) == 0x0002CC, "Member 'UProgressBar::BarFillType' has a wrong offset!");
static_assert(offsetof(UProgressBar, bIsMarquee) == 0x0002CD, "Member 'UProgressBar::bIsMarquee' has a wrong offset!");
static_assert(offsetof(UProgressBar, BorderPadding) == 0x0002D0, "Member 'UProgressBar::BorderPadding' has a wrong offset!");
static_assert(offsetof(UProgressBar, PercentDelegate) == 0x0002D8, "Member 'UProgressBar::PercentDelegate' has a wrong offset!");
static_assert(offsetof(UProgressBar, FillColorAndOpacity) == 0x0002E8, "Member 'UProgressBar::FillColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UProgressBar, FillColorAndOpacityDelegate) == 0x0002F8, "Member 'UProgressBar::FillColorAndOpacityDelegate' has a wrong offset!");

// Class UMG.RetainerBox
// 0x0030 (0x0150 - 0x0120)
class URetainerBox final : public UContentWidget
{
public:
	bool                                          RenderOnInvalidation;                              // 0x0120(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          RenderOnPhase;                                     // 0x0121(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_122[0x2];                                      // 0x0122(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         Phase;                                             // 0x0124(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PhaseCount;                                        // 0x0128(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12C[0x4];                                      // 0x012C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UMaterialInterface*                     EffectMaterial;                                    // 0x0130(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class FName                                   TextureParameter;                                  // 0x0138(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_140[0x10];                                     // 0x0140(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void RequestRender();
	void SetEffectMaterial(class UMaterialInterface* Param_EffectMaterial);
	void SetRenderingPhase(int32 RenderPhase, int32 TotalPhases);
	void SetTextureParameter(class FName Param_TextureParameter);

	class UMaterialInstanceDynamic* GetEffectMaterial() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RetainerBox">();
	}
	static class URetainerBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<URetainerBox>();
	}
};
static_assert(alignof(URetainerBox) == 0x000008, "Wrong alignment on URetainerBox");
static_assert(sizeof(URetainerBox) == 0x000150, "Wrong size on URetainerBox");
static_assert(offsetof(URetainerBox, RenderOnInvalidation) == 0x000120, "Member 'URetainerBox::RenderOnInvalidation' has a wrong offset!");
static_assert(offsetof(URetainerBox, RenderOnPhase) == 0x000121, "Member 'URetainerBox::RenderOnPhase' has a wrong offset!");
static_assert(offsetof(URetainerBox, Phase) == 0x000124, "Member 'URetainerBox::Phase' has a wrong offset!");
static_assert(offsetof(URetainerBox, PhaseCount) == 0x000128, "Member 'URetainerBox::PhaseCount' has a wrong offset!");
static_assert(offsetof(URetainerBox, EffectMaterial) == 0x000130, "Member 'URetainerBox::EffectMaterial' has a wrong offset!");
static_assert(offsetof(URetainerBox, TextureParameter) == 0x000138, "Member 'URetainerBox::TextureParameter' has a wrong offset!");

// Class UMG.RichTextBlock
// 0x02C8 (0x03F0 - 0x0128)
class URichTextBlock final : public UTextLayoutWidget
{
public:
	class FText                                   Text;                                              // 0x0128(0x0018)(Edit, Protected, NativeAccessSpecifierProtected)
	class UDataTable*                             TextStyleSet;                                      // 0x0140(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<TSubclassOf<class URichTextBlockDecorator>> DecoratorClasses;                                  // 0x0148(0x0010)(Edit, ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_158[0x278];                                    // 0x0158(0x0278)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class URichTextBlockDecorator*>        InstanceDecorators;                                // 0x03D0(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_3E0[0x10];                                     // 0x03E0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class URichTextBlockDecorator* GetDecoratorByClass(TSubclassOf<class URichTextBlockDecorator> DecoratorClass);
	void SetText(const class FText& InText);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RichTextBlock">();
	}
	static class URichTextBlock* GetDefaultObj()
	{
		return GetDefaultObjImpl<URichTextBlock>();
	}
};
static_assert(alignof(URichTextBlock) == 0x000008, "Wrong alignment on URichTextBlock");
static_assert(sizeof(URichTextBlock) == 0x0003F0, "Wrong size on URichTextBlock");
static_assert(offsetof(URichTextBlock, Text) == 0x000128, "Member 'URichTextBlock::Text' has a wrong offset!");
static_assert(offsetof(URichTextBlock, TextStyleSet) == 0x000140, "Member 'URichTextBlock::TextStyleSet' has a wrong offset!");
static_assert(offsetof(URichTextBlock, DecoratorClasses) == 0x000148, "Member 'URichTextBlock::DecoratorClasses' has a wrong offset!");
static_assert(offsetof(URichTextBlock, InstanceDecorators) == 0x0003D0, "Member 'URichTextBlock::InstanceDecorators' has a wrong offset!");

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

// Class UMG.RichTextBlockImageDecorator
// 0x0008 (0x0030 - 0x0028)
class URichTextBlockImageDecorator : public URichTextBlockDecorator
{
public:
	class UDataTable*                             ImageSet;                                          // 0x0028(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

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

// Class UMG.SafeZone
// 0x0018 (0x0138 - 0x0120)
class USafeZone final : public UContentWidget
{
public:
	bool                                          PadLeft;                                           // 0x0120(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          PadRight;                                          // 0x0121(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          PadTop;                                            // 0x0122(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          PadBottom;                                         // 0x0123(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_124[0x14];                                     // 0x0124(0x0014)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetSidesToPad(bool InPadLeft, bool InPadRight, bool InPadTop, bool InPadBottom);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SafeZone">();
	}
	static class USafeZone* GetDefaultObj()
	{
		return GetDefaultObjImpl<USafeZone>();
	}
};
static_assert(alignof(USafeZone) == 0x000008, "Wrong alignment on USafeZone");
static_assert(sizeof(USafeZone) == 0x000138, "Wrong size on USafeZone");
static_assert(offsetof(USafeZone, PadLeft) == 0x000120, "Member 'USafeZone::PadLeft' has a wrong offset!");
static_assert(offsetof(USafeZone, PadRight) == 0x000121, "Member 'USafeZone::PadRight' has a wrong offset!");
static_assert(offsetof(USafeZone, PadTop) == 0x000122, "Member 'USafeZone::PadTop' has a wrong offset!");
static_assert(offsetof(USafeZone, PadBottom) == 0x000123, "Member 'USafeZone::PadBottom' has a wrong offset!");

// Class UMG.SafeZoneSlot
// 0x0028 (0x0060 - 0x0038)
class USafeZoneSlot final : public UPanelSlot
{
public:
	bool                                          bIsTitleSafe;                                      // 0x0038(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x3];                                       // 0x0039(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMargin                                SafeAreaScale;                                     // 0x003C(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HAlign;                                            // 0x004C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VAlign;                                            // 0x004D(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4E[0x2];                                       // 0x004E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMargin                                Padding;                                           // 0x0050(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SafeZoneSlot">();
	}
	static class USafeZoneSlot* GetDefaultObj()
	{
		return GetDefaultObjImpl<USafeZoneSlot>();
	}
};
static_assert(alignof(USafeZoneSlot) == 0x000008, "Wrong alignment on USafeZoneSlot");
static_assert(sizeof(USafeZoneSlot) == 0x000060, "Wrong size on USafeZoneSlot");
static_assert(offsetof(USafeZoneSlot, bIsTitleSafe) == 0x000038, "Member 'USafeZoneSlot::bIsTitleSafe' has a wrong offset!");
static_assert(offsetof(USafeZoneSlot, SafeAreaScale) == 0x00003C, "Member 'USafeZoneSlot::SafeAreaScale' has a wrong offset!");
static_assert(offsetof(USafeZoneSlot, HAlign) == 0x00004C, "Member 'USafeZoneSlot::HAlign' has a wrong offset!");
static_assert(offsetof(USafeZoneSlot, VAlign) == 0x00004D, "Member 'USafeZoneSlot::VAlign' has a wrong offset!");
static_assert(offsetof(USafeZoneSlot, Padding) == 0x000050, "Member 'USafeZoneSlot::Padding' has a wrong offset!");

// Class UMG.ScaleBox
// 0x0020 (0x0140 - 0x0120)
class UScaleBox final : public UContentWidget
{
public:
	EStretch                                      Stretch;                                           // 0x0120(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EStretchDirection                             StretchDirection;                                  // 0x0121(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_122[0x2];                                      // 0x0122(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         UserSpecifiedScale;                                // 0x0124(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IgnoreInheritedScale;                              // 0x0128(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSingleLayoutPass;                                 // 0x0129(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12A[0x16];                                     // 0x012A(0x0016)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetIgnoreInheritedScale(bool bInIgnoreInheritedScale);
	void SetStretch(EStretch InStretch);
	void SetStretchDirection(EStretchDirection InStretchDirection);
	void SetUserSpecifiedScale(float InUserSpecifiedScale);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ScaleBox">();
	}
	static class UScaleBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UScaleBox>();
	}
};
static_assert(alignof(UScaleBox) == 0x000008, "Wrong alignment on UScaleBox");
static_assert(sizeof(UScaleBox) == 0x000140, "Wrong size on UScaleBox");
static_assert(offsetof(UScaleBox, Stretch) == 0x000120, "Member 'UScaleBox::Stretch' has a wrong offset!");
static_assert(offsetof(UScaleBox, StretchDirection) == 0x000121, "Member 'UScaleBox::StretchDirection' has a wrong offset!");
static_assert(offsetof(UScaleBox, UserSpecifiedScale) == 0x000124, "Member 'UScaleBox::UserSpecifiedScale' has a wrong offset!");
static_assert(offsetof(UScaleBox, IgnoreInheritedScale) == 0x000128, "Member 'UScaleBox::IgnoreInheritedScale' has a wrong offset!");
static_assert(offsetof(UScaleBox, bSingleLayoutPass) == 0x000129, "Member 'UScaleBox::bSingleLayoutPass' has a wrong offset!");

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

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

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

// Class UMG.ScrollBar
// 0x04F8 (0x0600 - 0x0108)
class UScrollBar final : public UWidget
{
public:
	struct FScrollBarStyle                        WidgetStyle;                                       // 0x0108(0x04D0)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	class USlateWidgetStyleAsset*                 Style;                                             // 0x05D8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAlwaysShowScrollbar;                              // 0x05E0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EOrientation                                  Orientation;                                       // 0x05E1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5E2[0x2];                                      // 0x05E2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              Thickness;                                         // 0x05E4(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5EC[0x14];                                     // 0x05EC(0x0014)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetState(float InOffsetFraction, float InThumbSizeFraction);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ScrollBar">();
	}
	static class UScrollBar* GetDefaultObj()
	{
		return GetDefaultObjImpl<UScrollBar>();
	}
};
static_assert(alignof(UScrollBar) == 0x000008, "Wrong alignment on UScrollBar");
static_assert(sizeof(UScrollBar) == 0x000600, "Wrong size on UScrollBar");
static_assert(offsetof(UScrollBar, WidgetStyle) == 0x000108, "Member 'UScrollBar::WidgetStyle' has a wrong offset!");
static_assert(offsetof(UScrollBar, Style) == 0x0005D8, "Member 'UScrollBar::Style' has a wrong offset!");
static_assert(offsetof(UScrollBar, bAlwaysShowScrollbar) == 0x0005E0, "Member 'UScrollBar::bAlwaysShowScrollbar' has a wrong offset!");
static_assert(offsetof(UScrollBar, Orientation) == 0x0005E1, "Member 'UScrollBar::Orientation' has a wrong offset!");
static_assert(offsetof(UScrollBar, Thickness) == 0x0005E4, "Member 'UScrollBar::Thickness' has a wrong offset!");

// Class UMG.ScrollBoxSlot
// 0x0020 (0x0058 - 0x0038)
class UScrollBoxSlot final : public UPanelSlot
{
public:
	struct FMargin                                Padding;                                           // 0x0038(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0048(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0049(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4A[0xE];                                       // 0x004A(0x000E)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

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

// Class UMG.SizeBox
// 0x0030 (0x0150 - 0x0120)
class USizeBox : public UContentWidget
{
public:
	uint8                                         bOverride_WidthOverride : 1;                       // 0x0120(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverride_HeightOverride : 1;                      // 0x0120(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverride_MinDesiredWidth : 1;                     // 0x0120(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverride_MinDesiredHeight : 1;                    // 0x0120(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverride_MaxDesiredWidth : 1;                     // 0x0120(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverride_MaxDesiredHeight : 1;                    // 0x0120(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverride_MaxAspectRatio : 1;                      // 0x0120(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_121[0x3];                                      // 0x0121(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         WidthOverride;                                     // 0x0124(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HeightOverride;                                    // 0x0128(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinDesiredWidth;                                   // 0x012C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinDesiredHeight;                                  // 0x0130(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDesiredWidth;                                   // 0x0134(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDesiredHeight;                                  // 0x0138(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxAspectRatio;                                    // 0x013C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_140[0x10];                                     // 0x0140(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ClearHeightOverride();
	void ClearMaxAspectRatio();
	void ClearMaxDesiredHeight();
	void ClearMaxDesiredWidth();
	void ClearMinDesiredHeight();
	void ClearMinDesiredWidth();
	void ClearWidthOverride();
	void SetHeightOverride(float InHeightOverride);
	void SetMaxAspectRatio(float InMaxAspectRatio);
	void SetMaxDesiredHeight(float InMaxDesiredHeight);
	void SetMaxDesiredWidth(float InMaxDesiredWidth);
	void SetMinDesiredHeight(float InMinDesiredHeight);
	void SetMinDesiredWidth(float InMinDesiredWidth);
	void SetWidthOverride(float InWidthOverride);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SizeBox">();
	}
	static class USizeBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<USizeBox>();
	}
};
static_assert(alignof(USizeBox) == 0x000008, "Wrong alignment on USizeBox");
static_assert(sizeof(USizeBox) == 0x000150, "Wrong size on USizeBox");
static_assert(offsetof(USizeBox, WidthOverride) == 0x000124, "Member 'USizeBox::WidthOverride' has a wrong offset!");
static_assert(offsetof(USizeBox, HeightOverride) == 0x000128, "Member 'USizeBox::HeightOverride' has a wrong offset!");
static_assert(offsetof(USizeBox, MinDesiredWidth) == 0x00012C, "Member 'USizeBox::MinDesiredWidth' has a wrong offset!");
static_assert(offsetof(USizeBox, MinDesiredHeight) == 0x000130, "Member 'USizeBox::MinDesiredHeight' has a wrong offset!");
static_assert(offsetof(USizeBox, MaxDesiredWidth) == 0x000134, "Member 'USizeBox::MaxDesiredWidth' has a wrong offset!");
static_assert(offsetof(USizeBox, MaxDesiredHeight) == 0x000138, "Member 'USizeBox::MaxDesiredHeight' has a wrong offset!");
static_assert(offsetof(USizeBox, MaxAspectRatio) == 0x00013C, "Member 'USizeBox::MaxAspectRatio' has a wrong offset!");

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

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

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

// Class UMG.SlateBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class USlateBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FVector2D AbsoluteToLocal(const struct FGeometry& Geometry, const struct FVector2D& AbsoluteCoordinate);
	static void AbsoluteToViewport(class UObject* WorldContextObject, const struct FVector2D& AbsoluteDesktopCoordinate, struct FVector2D* PixelPosition, struct FVector2D* ViewportPosition);
	static bool EqualEqual_SlateBrush(const struct FSlateBrush& A, const struct FSlateBrush& B);
	static struct FVector2D GetAbsoluteSize(const struct FGeometry& Geometry);
	static struct FVector2D GetLocalSize(const struct FGeometry& Geometry);
	static bool IsUnderLocation(const struct FGeometry& Geometry, const struct FVector2D& AbsoluteCoordinate);
	static struct FVector2D LocalToAbsolute(const struct FGeometry& Geometry, const struct FVector2D& LocalCoordinate);
	static void LocalToViewport(class UObject* WorldContextObject, const struct FGeometry& Geometry, const struct FVector2D& LocalCoordinate, struct FVector2D* PixelPosition, struct FVector2D* ViewportPosition);
	static void ScreenToViewport(class UObject* WorldContextObject, const struct FVector2D& ScreenPosition, struct FVector2D* ViewportPosition);
	static void ScreenToWidgetAbsolute(class UObject* WorldContextObject, const struct FVector2D& ScreenPosition, struct FVector2D* AbsoluteCoordinate);
	static void ScreenToWidgetLocal(class UObject* WorldContextObject, const struct FGeometry& Geometry, const struct FVector2D& ScreenPosition, struct FVector2D* LocalCoordinate);
	static float TransformScalarAbsoluteToLocal(const struct FGeometry& Geometry, float AbsoluteScalar);
	static float TransformScalarLocalToAbsolute(const struct FGeometry& Geometry, float LocalScalar);
	static struct FVector2D TransformVectorAbsoluteToLocal(const struct FGeometry& Geometry, const struct FVector2D& AbsoluteVector);
	static struct FVector2D TransformVectorLocalToAbsolute(const struct FGeometry& Geometry, const struct FVector2D& LocalVector);

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

// Class UMG.SlateVectorArtData
// 0x0038 (0x0060 - 0x0028)
class USlateVectorArtData final : public UObject
{
public:
	TArray<struct FSlateMeshVertex>               VertexData;                                        // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<uint32>                                IndexData;                                         // 0x0038(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	class UMaterialInterface*                     Material;                                          // 0x0048(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FVector2D                              ExtentMin;                                         // 0x0050(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FVector2D                              ExtentMax;                                         // 0x0058(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SlateVectorArtData">();
	}
	static class USlateVectorArtData* GetDefaultObj()
	{
		return GetDefaultObjImpl<USlateVectorArtData>();
	}
};
static_assert(alignof(USlateVectorArtData) == 0x000008, "Wrong alignment on USlateVectorArtData");
static_assert(sizeof(USlateVectorArtData) == 0x000060, "Wrong size on USlateVectorArtData");
static_assert(offsetof(USlateVectorArtData, VertexData) == 0x000028, "Member 'USlateVectorArtData::VertexData' has a wrong offset!");
static_assert(offsetof(USlateVectorArtData, IndexData) == 0x000038, "Member 'USlateVectorArtData::IndexData' has a wrong offset!");
static_assert(offsetof(USlateVectorArtData, Material) == 0x000048, "Member 'USlateVectorArtData::Material' has a wrong offset!");
static_assert(offsetof(USlateVectorArtData, ExtentMin) == 0x000050, "Member 'USlateVectorArtData::ExtentMin' has a wrong offset!");
static_assert(offsetof(USlateVectorArtData, ExtentMax) == 0x000058, "Member 'USlateVectorArtData::ExtentMax' has a wrong offset!");

// Class UMG.Spacer
// 0x0018 (0x0120 - 0x0108)
class USpacer final : public UWidget
{
public:
	struct FVector2D                              Size;                                              // 0x0108(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_110[0x10];                                     // 0x0110(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetSize(const struct FVector2D& InSize);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Spacer">();
	}
	static class USpacer* GetDefaultObj()
	{
		return GetDefaultObjImpl<USpacer>();
	}
};
static_assert(alignof(USpacer) == 0x000008, "Wrong alignment on USpacer");
static_assert(sizeof(USpacer) == 0x000120, "Wrong size on USpacer");
static_assert(offsetof(USpacer, Size) == 0x000108, "Member 'USpacer::Size' has a wrong offset!");

// Class UMG.SpinBox
// 0x0400 (0x0508 - 0x0108)
class USpinBox final : public UWidget
{
public:
	float                                         Value;                                             // 0x0108(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             ValueDelegate;                                     // 0x010C(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_11C[0x4];                                      // 0x011C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSpinBoxStyle                          WidgetStyle;                                       // 0x0120(0x02E8)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	class USlateWidgetStyleAsset*                 Style;                                             // 0x0408(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Delta;                                             // 0x0410(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SliderExponent;                                    // 0x0414(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateFontInfo                         Font;                                              // 0x0418(0x0050)(Edit, BlueprintVisible, BlueprintReadOnly, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextJustify                                  Justification;                                     // 0x0468(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_469[0x3];                                      // 0x0469(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinDesiredWidth;                                   // 0x046C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ClearKeyboardFocusOnCommit;                        // 0x0470(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          SelectAllTextOnCommit;                             // 0x0471(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_472[0x6];                                      // 0x0472(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateColor                            ForegroundColor;                                   // 0x0478(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnValueChanged;                                    // 0x04A0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnValueCommitted;                                  // 0x04B0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnBeginSliderMovement;                             // 0x04C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	UMulticastDelegateProperty_                   OnEndSliderMovement;                               // 0x04D0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         bOverride_MinValue : 1;                            // 0x04E0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bOverride_MaxValue : 1;                            // 0x04E0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bOverride_MinSliderValue : 1;                      // 0x04E0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bOverride_MaxSliderValue : 1;                      // 0x04E0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_4E1[0x3];                                      // 0x04E1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinValue;                                          // 0x04E4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         MaxValue;                                          // 0x04E8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         MinSliderValue;                                    // 0x04EC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         MaxSliderValue;                                    // 0x04F0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_4F4[0x14];                                     // 0x04F4(0x0014)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ClearMaxSliderValue();
	void ClearMaxValue();
	void ClearMinSliderValue();
	void ClearMinValue();
	void OnSpinBoxBeginSliderMovement__DelegateSignature();
	void OnSpinBoxValueChangedEvent__DelegateSignature(float InValue);
	void OnSpinBoxValueCommittedEvent__DelegateSignature(float InValue, ETextCommit CommitMethod);
	void SetForegroundColor(const struct FSlateColor& InForegroundColor);
	void SetMaxSliderValue(float NewValue);
	void SetMaxValue(float NewValue);
	void SetMinSliderValue(float NewValue);
	void SetMinValue(float NewValue);
	void SetValue(float NewValue);

	float GetMaxSliderValue() const;
	float GetMaxValue() const;
	float GetMinSliderValue() const;
	float GetMinValue() const;
	float GetValue() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SpinBox">();
	}
	static class USpinBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<USpinBox>();
	}
};
static_assert(alignof(USpinBox) == 0x000008, "Wrong alignment on USpinBox");
static_assert(sizeof(USpinBox) == 0x000508, "Wrong size on USpinBox");
static_assert(offsetof(USpinBox, Value) == 0x000108, "Member 'USpinBox::Value' has a wrong offset!");
static_assert(offsetof(USpinBox, ValueDelegate) == 0x00010C, "Member 'USpinBox::ValueDelegate' has a wrong offset!");
static_assert(offsetof(USpinBox, WidgetStyle) == 0x000120, "Member 'USpinBox::WidgetStyle' has a wrong offset!");
static_assert(offsetof(USpinBox, Style) == 0x000408, "Member 'USpinBox::Style' has a wrong offset!");
static_assert(offsetof(USpinBox, Delta) == 0x000410, "Member 'USpinBox::Delta' has a wrong offset!");
static_assert(offsetof(USpinBox, SliderExponent) == 0x000414, "Member 'USpinBox::SliderExponent' has a wrong offset!");
static_assert(offsetof(USpinBox, Font) == 0x000418, "Member 'USpinBox::Font' has a wrong offset!");
static_assert(offsetof(USpinBox, Justification) == 0x000468, "Member 'USpinBox::Justification' has a wrong offset!");
static_assert(offsetof(USpinBox, MinDesiredWidth) == 0x00046C, "Member 'USpinBox::MinDesiredWidth' has a wrong offset!");
static_assert(offsetof(USpinBox, ClearKeyboardFocusOnCommit) == 0x000470, "Member 'USpinBox::ClearKeyboardFocusOnCommit' has a wrong offset!");
static_assert(offsetof(USpinBox, SelectAllTextOnCommit) == 0x000471, "Member 'USpinBox::SelectAllTextOnCommit' has a wrong offset!");
static_assert(offsetof(USpinBox, ForegroundColor) == 0x000478, "Member 'USpinBox::ForegroundColor' has a wrong offset!");
static_assert(offsetof(USpinBox, OnValueChanged) == 0x0004A0, "Member 'USpinBox::OnValueChanged' has a wrong offset!");
static_assert(offsetof(USpinBox, OnValueCommitted) == 0x0004B0, "Member 'USpinBox::OnValueCommitted' has a wrong offset!");
static_assert(offsetof(USpinBox, OnBeginSliderMovement) == 0x0004C0, "Member 'USpinBox::OnBeginSliderMovement' has a wrong offset!");
static_assert(offsetof(USpinBox, OnEndSliderMovement) == 0x0004D0, "Member 'USpinBox::OnEndSliderMovement' has a wrong offset!");
static_assert(offsetof(USpinBox, MinValue) == 0x0004E4, "Member 'USpinBox::MinValue' has a wrong offset!");
static_assert(offsetof(USpinBox, MaxValue) == 0x0004E8, "Member 'USpinBox::MaxValue' has a wrong offset!");
static_assert(offsetof(USpinBox, MinSliderValue) == 0x0004EC, "Member 'USpinBox::MinSliderValue' has a wrong offset!");
static_assert(offsetof(USpinBox, MaxSliderValue) == 0x0004F0, "Member 'USpinBox::MaxSliderValue' has a wrong offset!");

// Class UMG.TextBinding
// 0x0008 (0x0068 - 0x0060)
class UTextBinding final : public UPropertyBinding
{
public:
	uint8                                         Pad_60[0x8];                                       // 0x0060(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class FString GetStringValue() const;
	class FText GetTextValue() const;

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

// Class UMG.Throbber
// 0x00A8 (0x01B0 - 0x0108)
class UThrobber final : public UWidget
{
public:
	int32                                         NumberOfPieces;                                    // 0x0108(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAnimateHorizontally;                              // 0x010C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAnimateVertically;                                // 0x010D(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAnimateOpacity;                                   // 0x010E(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_10F[0x1];                                      // 0x010F(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	class USlateBrushAsset*                       PieceImage;                                        // 0x0110(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSlateBrush                            Image;                                             // 0x0118(0x0088)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	uint8                                         Pad_1A0[0x10];                                     // 0x01A0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetAnimateHorizontally(bool bInAnimateHorizontally);
	void SetAnimateOpacity(bool bInAnimateOpacity);
	void SetAnimateVertically(bool bInAnimateVertically);
	void SetNumberOfPieces(int32 InNumberOfPieces);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Throbber">();
	}
	static class UThrobber* GetDefaultObj()
	{
		return GetDefaultObjImpl<UThrobber>();
	}
};
static_assert(alignof(UThrobber) == 0x000008, "Wrong alignment on UThrobber");
static_assert(sizeof(UThrobber) == 0x0001B0, "Wrong size on UThrobber");
static_assert(offsetof(UThrobber, NumberOfPieces) == 0x000108, "Member 'UThrobber::NumberOfPieces' has a wrong offset!");
static_assert(offsetof(UThrobber, bAnimateHorizontally) == 0x00010C, "Member 'UThrobber::bAnimateHorizontally' has a wrong offset!");
static_assert(offsetof(UThrobber, bAnimateVertically) == 0x00010D, "Member 'UThrobber::bAnimateVertically' has a wrong offset!");
static_assert(offsetof(UThrobber, bAnimateOpacity) == 0x00010E, "Member 'UThrobber::bAnimateOpacity' has a wrong offset!");
static_assert(offsetof(UThrobber, PieceImage) == 0x000110, "Member 'UThrobber::PieceImage' has a wrong offset!");
static_assert(offsetof(UThrobber, Image) == 0x000118, "Member 'UThrobber::Image' has a wrong offset!");

// Class UMG.UMGSequencePlayer
// 0x06C8 (0x06F0 - 0x0028)
class UUMGSequencePlayer final : public UObject
{
public:
	uint8                                         Pad_28[0x348];                                     // 0x0028(0x0348)(Fixing Size After Last Property [ Dumper-7 ])
	class UWidgetAnimation*                       Animation;                                         // 0x0370(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_378[0x378];                                    // 0x0378(0x0378)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetUserTag(class FName InUserTag);

	class FName GetUserTag() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"UMGSequencePlayer">();
	}
	static class UUMGSequencePlayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UUMGSequencePlayer>();
	}
};
static_assert(alignof(UUMGSequencePlayer) == 0x000008, "Wrong alignment on UUMGSequencePlayer");
static_assert(sizeof(UUMGSequencePlayer) == 0x0006F0, "Wrong size on UUMGSequencePlayer");
static_assert(offsetof(UUMGSequencePlayer, Animation) == 0x000370, "Member 'UUMGSequencePlayer::Animation' has a wrong offset!");

// Class UMG.UniformGridPanel
// 0x0028 (0x0148 - 0x0120)
class UUniformGridPanel final : public UPanelWidget
{
public:
	struct FMargin                                SlotPadding;                                       // 0x0120(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         MinDesiredSlotWidth;                               // 0x0130(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinDesiredSlotHeight;                              // 0x0134(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_138[0x10];                                     // 0x0138(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UUniformGridSlot* AddChildToUniformGrid(class UWidget* Content);
	void SetMinDesiredSlotHeight(float InMinDesiredSlotHeight);
	void SetMinDesiredSlotWidth(float InMinDesiredSlotWidth);
	void SetSlotPadding(const struct FMargin& InSlotPadding);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"UniformGridPanel">();
	}
	static class UUniformGridPanel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UUniformGridPanel>();
	}
};
static_assert(alignof(UUniformGridPanel) == 0x000008, "Wrong alignment on UUniformGridPanel");
static_assert(sizeof(UUniformGridPanel) == 0x000148, "Wrong size on UUniformGridPanel");
static_assert(offsetof(UUniformGridPanel, SlotPadding) == 0x000120, "Member 'UUniformGridPanel::SlotPadding' has a wrong offset!");
static_assert(offsetof(UUniformGridPanel, MinDesiredSlotWidth) == 0x000130, "Member 'UUniformGridPanel::MinDesiredSlotWidth' has a wrong offset!");
static_assert(offsetof(UUniformGridPanel, MinDesiredSlotHeight) == 0x000134, "Member 'UUniformGridPanel::MinDesiredSlotHeight' has a wrong offset!");

// Class UMG.UniformGridSlot
// 0x0018 (0x0050 - 0x0038)
class UUniformGridSlot final : public UPanelSlot
{
public:
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0038(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0039(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3A[0x2];                                       // 0x003A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         Row;                                               // 0x003C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Column;                                            // 0x0040(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0xC];                                       // 0x0044(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetColumn(int32 InColumn);
	void SetHorizontalAlignment(EHorizontalAlignment InHorizontalAlignment);
	void SetRow(int32 InRow);
	void SetVerticalAlignment(EVerticalAlignment InVerticalAlignment);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"UniformGridSlot">();
	}
	static class UUniformGridSlot* GetDefaultObj()
	{
		return GetDefaultObjImpl<UUniformGridSlot>();
	}
};
static_assert(alignof(UUniformGridSlot) == 0x000008, "Wrong alignment on UUniformGridSlot");
static_assert(sizeof(UUniformGridSlot) == 0x000050, "Wrong size on UUniformGridSlot");
static_assert(offsetof(UUniformGridSlot, HorizontalAlignment) == 0x000038, "Member 'UUniformGridSlot::HorizontalAlignment' has a wrong offset!");
static_assert(offsetof(UUniformGridSlot, VerticalAlignment) == 0x000039, "Member 'UUniformGridSlot::VerticalAlignment' has a wrong offset!");
static_assert(offsetof(UUniformGridSlot, Row) == 0x00003C, "Member 'UUniformGridSlot::Row' has a wrong offset!");
static_assert(offsetof(UUniformGridSlot, Column) == 0x000040, "Member 'UUniformGridSlot::Column' has a wrong offset!");

// Class UMG.VerticalBox
// 0x0010 (0x0130 - 0x0120)
class UVerticalBox final : public UPanelWidget
{
public:
	uint8                                         Pad_120[0x10];                                     // 0x0120(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UVerticalBoxSlot* AddChildToVerticalBox(class UWidget* Content);

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

// Class UMG.VerticalBoxSlot
// 0x0028 (0x0060 - 0x0038)
class UVerticalBoxSlot final : public UPanelSlot
{
public:
	struct FMargin                                Padding;                                           // 0x0038(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FSlateChildSize                        Size;                                              // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0050(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0051(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_52[0xE];                                       // 0x0052(0x000E)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

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

// Class UMG.Viewport
// 0x0028 (0x0148 - 0x0120)
class UViewport final : public UContentWidget
{
public:
	struct FLinearColor                           BackgroundColor;                                   // 0x0120(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_130[0x18];                                     // 0x0130(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetViewLocation(const struct FVector& Location);
	void SetViewRotation(const struct FRotator& Rotation);
	class AActor* Spawn(TSubclassOf<class AActor> ActorClass);

	struct FVector GetViewLocation() const;
	class UWorld* GetViewportWorld() const;
	struct FRotator GetViewRotation() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Viewport">();
	}
	static class UViewport* GetDefaultObj()
	{
		return GetDefaultObjImpl<UViewport>();
	}
};
static_assert(alignof(UViewport) == 0x000008, "Wrong alignment on UViewport");
static_assert(sizeof(UViewport) == 0x000148, "Wrong size on UViewport");
static_assert(offsetof(UViewport, BackgroundColor) == 0x000120, "Member 'UViewport::BackgroundColor' has a wrong offset!");

// Class UMG.VisibilityBinding
// 0x0000 (0x0060 - 0x0060)
class UVisibilityBinding final : public UPropertyBinding
{
public:
	ESlateVisibility GetValue() const;

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

// Class UMG.WidgetAnimation
// 0x0030 (0x0378 - 0x0348)
class UWidgetAnimation final : public UMovieSceneSequence
{
public:
	class UMovieScene*                            MovieScene;                                        // 0x0348(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FWidgetAnimationBinding>        AnimationBindings;                                 // 0x0350(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	bool                                          bLegacyFinishOnStop;                               // 0x0360(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_361[0x7];                                      // 0x0361(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 DisplayLabel;                                      // 0x0368(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void BindToAnimationFinished(class UUserWidget* Widget, TDelegate<void()> Delegate);
	void BindToAnimationStarted(class UUserWidget* Widget, TDelegate<void()> Delegate);
	void UnbindAllFromAnimationFinished(class UUserWidget* Widget);
	void UnbindAllFromAnimationStarted(class UUserWidget* Widget);
	void UnbindFromAnimationFinished(class UUserWidget* Widget, TDelegate<void()> Delegate);
	void UnbindFromAnimationStarted(class UUserWidget* Widget, TDelegate<void()> Delegate);

	float GetEndTime() const;
	float GetStartTime() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WidgetAnimation">();
	}
	static class UWidgetAnimation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWidgetAnimation>();
	}
};
static_assert(alignof(UWidgetAnimation) == 0x000008, "Wrong alignment on UWidgetAnimation");
static_assert(sizeof(UWidgetAnimation) == 0x000378, "Wrong size on UWidgetAnimation");
static_assert(offsetof(UWidgetAnimation, MovieScene) == 0x000348, "Member 'UWidgetAnimation::MovieScene' has a wrong offset!");
static_assert(offsetof(UWidgetAnimation, AnimationBindings) == 0x000350, "Member 'UWidgetAnimation::AnimationBindings' has a wrong offset!");
static_assert(offsetof(UWidgetAnimation, bLegacyFinishOnStop) == 0x000360, "Member 'UWidgetAnimation::bLegacyFinishOnStop' has a wrong offset!");
static_assert(offsetof(UWidgetAnimation, DisplayLabel) == 0x000368, "Member 'UWidgetAnimation::DisplayLabel' has a wrong offset!");

// Class UMG.WidgetAnimationDelegateBinding
// 0x0010 (0x0038 - 0x0028)
class UWidgetAnimationDelegateBinding final : public UDynamicBlueprintBinding
{
public:
	TArray<struct FBlueprintWidgetAnimationDelegateBinding> WidgetAnimationDelegateBindings;                   // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

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

// Class UMG.WidgetBinding
// 0x0000 (0x0060 - 0x0060)
class UWidgetBinding final : public UPropertyBinding
{
public:
	class UWidget* GetValue() const;

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

// Class UMG.WidgetBlueprintGeneratedClass
// 0x0070 (0x0350 - 0x02E0)
class UWidgetBlueprintGeneratedClass final : public UBlueprintGeneratedClass
{
public:
	class UWidgetTree*                            WidgetTree;                                        // 0x02E0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAllowTemplate : 1;                                // 0x02E8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowDynamicCreation : 1;                         // 0x02E8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bValidTemplate : 1;                                // 0x02E8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bTemplateInitialized : 1;                          // 0x02E8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bCookedTemplate : 1;                               // 0x02E8(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bClassRequiresNativeTick : 1;                      // 0x02E8(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_2E9[0x7];                                      // 0x02E9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FDelegateRuntimeBinding>        Bindings;                                          // 0x02F0(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class UWidgetAnimation*>               Animations;                                        // 0x0300(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class FName>                           NamedSlots;                                        // 0x0310(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UUserWidget>             TemplateAsset;                                     // 0x0320(0x0028)(ExportObject, InstancedReference, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UUserWidget*                            Template;                                          // 0x0348(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WidgetBlueprintGeneratedClass">();
	}
	static class UWidgetBlueprintGeneratedClass* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWidgetBlueprintGeneratedClass>();
	}
};
static_assert(alignof(UWidgetBlueprintGeneratedClass) == 0x000008, "Wrong alignment on UWidgetBlueprintGeneratedClass");
static_assert(sizeof(UWidgetBlueprintGeneratedClass) == 0x000350, "Wrong size on UWidgetBlueprintGeneratedClass");
static_assert(offsetof(UWidgetBlueprintGeneratedClass, WidgetTree) == 0x0002E0, "Member 'UWidgetBlueprintGeneratedClass::WidgetTree' has a wrong offset!");
static_assert(offsetof(UWidgetBlueprintGeneratedClass, Bindings) == 0x0002F0, "Member 'UWidgetBlueprintGeneratedClass::Bindings' has a wrong offset!");
static_assert(offsetof(UWidgetBlueprintGeneratedClass, Animations) == 0x000300, "Member 'UWidgetBlueprintGeneratedClass::Animations' has a wrong offset!");
static_assert(offsetof(UWidgetBlueprintGeneratedClass, NamedSlots) == 0x000310, "Member 'UWidgetBlueprintGeneratedClass::NamedSlots' has a wrong offset!");
static_assert(offsetof(UWidgetBlueprintGeneratedClass, TemplateAsset) == 0x000320, "Member 'UWidgetBlueprintGeneratedClass::TemplateAsset' has a wrong offset!");
static_assert(offsetof(UWidgetBlueprintGeneratedClass, Template) == 0x000348, "Member 'UWidgetBlueprintGeneratedClass::Template' has a wrong offset!");

// Class UMG.WidgetBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class UWidgetBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void CancelDragDrop();
	static struct FEventReply CaptureJoystick(struct FEventReply& Reply, class UWidget* CapturingWidget, bool bInAllJoysticks);
	static struct FEventReply CaptureMouse(struct FEventReply& Reply, class UWidget* CapturingWidget);
	static struct FEventReply ClearUserFocus(struct FEventReply& Reply, bool bInAllUsers);
	static class UUserWidget* Create(class UObject* WorldContextObject, TSubclassOf<class UUserWidget> WidgetType, class APlayerController* OwningPlayer);
	static class UDragDropOperation* CreateDragDropOperation(TSubclassOf<class UDragDropOperation> OperationClass);
	static struct FEventReply DetectDrag(struct FEventReply& Reply, class UWidget* WidgetDetectingDrag, const struct FKey& DragKey);
	static struct FEventReply DetectDragIfPressed(const struct FPointerEvent& PointerEvent, class UWidget* WidgetDetectingDrag, const struct FKey& DragKey);
	static void DismissAllMenus();
	static void DrawBox(struct FPaintContext& Context, const struct FVector2D& Position, const struct FVector2D& Size, class USlateBrushAsset* Brush, const struct FLinearColor& Tint);
	static void DrawLine(struct FPaintContext& Context, const struct FVector2D& PositionA, const struct FVector2D& PositionB, const struct FLinearColor& Tint, bool bAntiAlias);
	static void DrawLines(struct FPaintContext& Context, const TArray<struct FVector2D>& Points, const struct FLinearColor& Tint, bool bAntiAlias);
	static void DrawText(struct FPaintContext& Context, const class FString& InString, const struct FVector2D& Position, const struct FLinearColor& Tint);
	static void DrawTextFormatted(struct FPaintContext& Context, const class FText& Text, const struct FVector2D& Position, class UFont* Font, int32 FontSize, class FName FontTypeFace, const struct FLinearColor& Tint);
	static struct FEventReply EndDragDrop(struct FEventReply& Reply);
	static void GetAllWidgetsOfClass(class UObject* WorldContextObject, TArray<class UUserWidget*>* FoundWidgets, TSubclassOf<class UUserWidget> WidgetClass, bool TopLevelOnly);
	static void GetAllWidgetsWithInterface(class UObject* WorldContextObject, TSubclassOf<class IInterface> Interface, TArray<class UUserWidget*>* FoundWidgets, bool TopLevelOnly);
	static class UObject* GetBrushResource(const struct FSlateBrush& Brush);
	static class UMaterialInterface* GetBrushResourceAsMaterial(const struct FSlateBrush& Brush);
	static class UTexture2D* GetBrushResourceAsTexture2D(const struct FSlateBrush& Brush);
	static class UDragDropOperation* GetDragDroppingContent();
	static class UMaterialInstanceDynamic* GetDynamicMaterial(struct FSlateBrush& Brush);
	static struct FInputEvent GetInputEventFromCharacterEvent(const struct FCharacterEvent& Event);
	static struct FInputEvent GetInputEventFromKeyEvent(const struct FKeyEvent& Event);
	static struct FInputEvent GetInputEventFromNavigationEvent(const struct FNavigationEvent& Event);
	static struct FInputEvent GetInputEventFromPointerEvent(const struct FPointerEvent& Event);
	static struct FKeyEvent GetKeyEventFromAnalogInputEvent(const struct FAnalogInputEvent& Event);
	static void GetSafeZonePadding(class UObject* WorldContextObject, struct FVector4* SafePadding, struct FVector2D* SafePaddingScale, struct FVector4* SpillOverPadding);
	static struct FEventReply Handled();
	static bool IsDragDropping();
	static struct FEventReply LockMouse(struct FEventReply& Reply, class UWidget* CapturingWidget);
	static struct FSlateBrush MakeBrushFromAsset(class USlateBrushAsset* BrushAsset);
	static struct FSlateBrush MakeBrushFromMaterial(class UMaterialInterface* Material, int32 Width, int32 Height);
	static struct FSlateBrush MakeBrushFromTexture(class UTexture2D* Texture, int32 Width, int32 Height);
	static struct FSlateBrush NoResourceBrush();
	static struct FEventReply ReleaseJoystickCapture(struct FEventReply& Reply, bool bInAllJoysticks);
	static struct FEventReply ReleaseMouseCapture(struct FEventReply& Reply);
	static void RestorePreviousWindowTitleBarState();
	static void SetBrushResourceToMaterial(struct FSlateBrush& Brush, class UMaterialInterface* Material);
	static void SetBrushResourceToTexture(struct FSlateBrush& Brush, class UTexture2D* Texture);
	static void SetFocusToGameViewport();
	static bool SetHardwareCursor(class UObject* WorldContextObject, EMouseCursor CursorShape, class FName CursorName, const struct FVector2D& HotSpot);
	static void SetInputMode_GameAndUI(class APlayerController* Target, class UWidget* InWidgetToFocus, bool bLockMouseToViewport, bool bHideCursorDuringCapture);
	static void SetInputMode_GameAndUIEx(class APlayerController* PlayerController, class UWidget* InWidgetToFocus, EMouseLockMode InMouseLockMode, bool bHideCursorDuringCapture);
	static void SetInputMode_GameOnly(class APlayerController* PlayerController);
	static void SetInputMode_UIOnly(class APlayerController* Target, class UWidget* InWidgetToFocus, bool bLockMouseToViewport);
	static void SetInputMode_UIOnlyEx(class APlayerController* PlayerController, class UWidget* InWidgetToFocus, EMouseLockMode InMouseLockMode);
	static struct FEventReply SetMousePosition(struct FEventReply& Reply, const struct FVector2D& NewMousePosition);
	static struct FEventReply SetUserFocus(struct FEventReply& Reply, class UWidget* FocusWidget, bool bInAllUsers);
	static void SetWindowTitleBarCloseButtonActive(bool bActive);
	static void SetWindowTitleBarOnCloseClickedDelegate(TDelegate<void()> Delegate);
	static void SetWindowTitleBarState(class UWidget* TitleBarContent, EWindowTitleBarMode Mode, bool bTitleBarDragEnabled, bool bWindowButtonsVisible, bool bTitleBarVisible);
	static struct FEventReply Unhandled();
	static struct FEventReply UnlockMouse(struct FEventReply& Reply);

	void OnGameWindowCloseButtonClickedDelegate__DelegateSignature();

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

// Class UMG.WidgetComponent
// 0x0120 (0x06C0 - 0x05A0)
class UWidgetComponent final : public UMeshComponent
{
public:
	EWidgetSpace                                  Space;                                             // 0x05A0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EWidgetTimingPolicy                           TimingPolicy;                                      // 0x05A1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_5A2[0x6];                                      // 0x05A2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UUserWidget>                WidgetClass;                                       // 0x05A8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FIntPoint                              DrawSize;                                          // 0x05B0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bManuallyRedraw;                                   // 0x05B8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bRedrawRequested;                                  // 0x05B9(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_5BA[0x2];                                      // 0x05BA(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         RedrawTime;                                        // 0x05BC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_5C0[0x8];                                      // 0x05C0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FIntPoint                              CurrentDrawSize;                                   // 0x05C8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bDrawAtDesiredSize;                                // 0x05D0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_5D1[0x3];                                      // 0x05D1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              Pivot;                                             // 0x05D4(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bReceiveHardwareInput;                             // 0x05DC(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bWindowFocusable;                                  // 0x05DD(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bApplyGammaCorrection;                             // 0x05DE(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_5DF[0x1];                                      // 0x05DF(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	class ULocalPlayer*                           OwnerPlayer;                                       // 0x05E0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FLinearColor                           BackgroundColor;                                   // 0x05E8(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FLinearColor                           TintColorAndOpacity;                               // 0x05F8(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         OpacityFromTexture;                                // 0x0608(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EWidgetBlendMode                              BlendMode;                                         // 0x060C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsTwoSided;                                       // 0x060D(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          TickWhenOffscreen;                                 // 0x060E(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_60F[0x1];                                      // 0x060F(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	class UUserWidget*                            Widget;                                            // 0x0610(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_618[0x20];                                     // 0x0618(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	class UBodySetup*                             BodySetup;                                         // 0x0638(0x0008)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMaterialInterface*                     TranslucentMaterial;                               // 0x0640(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMaterialInterface*                     TranslucentMaterial_OneSided;                      // 0x0648(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMaterialInterface*                     OpaqueMaterial;                                    // 0x0650(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMaterialInterface*                     OpaqueMaterial_OneSided;                           // 0x0658(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMaterialInterface*                     MaskedMaterial;                                    // 0x0660(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMaterialInterface*                     MaskedMaterial_OneSided;                           // 0x0668(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UTextureRenderTarget2D*                 RenderTarget;                                      // 0x0670(0x0008)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMaterialInstanceDynamic*               MaterialInstance;                                  // 0x0678(0x0008)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bAddedToScreen;                                    // 0x0680(0x0001)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bEditTimeUsable;                                   // 0x0681(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_682[0x2];                                      // 0x0682(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   SharedLayerName;                                   // 0x0684(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LayerZOrder;                                       // 0x068C(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EWidgetGeometryMode                           GeometryMode;                                      // 0x0690(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_691[0x3];                                      // 0x0691(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CylinderArcAngle;                                  // 0x0694(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_698[0x28];                                     // 0x0698(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void RequestRedraw();
	void SetBackgroundColor(const struct FLinearColor& NewBackgroundColor);
	void SetDrawSize(const struct FVector2D& Size);
	void SetManuallyRedraw(bool bUseManualRedraw);
	void SetOwnerPlayer(class ULocalPlayer* LocalPlayer);
	void SetTintColorAndOpacity(const struct FLinearColor& NewTintColorAndOpacity);
	void SetWidget(class UUserWidget* Param_Widget);

	struct FVector2D GetDrawSize() const;
	class UMaterialInstanceDynamic* GetMaterialInstance() const;
	class ULocalPlayer* GetOwnerPlayer() const;
	class UTextureRenderTarget2D* GetRenderTarget() const;
	class UUserWidget* GetUserWidgetObject() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WidgetComponent">();
	}
	static class UWidgetComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWidgetComponent>();
	}
};
static_assert(alignof(UWidgetComponent) == 0x000008, "Wrong alignment on UWidgetComponent");
static_assert(sizeof(UWidgetComponent) == 0x0006C0, "Wrong size on UWidgetComponent");
static_assert(offsetof(UWidgetComponent, Space) == 0x0005A0, "Member 'UWidgetComponent::Space' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, TimingPolicy) == 0x0005A1, "Member 'UWidgetComponent::TimingPolicy' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, WidgetClass) == 0x0005A8, "Member 'UWidgetComponent::WidgetClass' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, DrawSize) == 0x0005B0, "Member 'UWidgetComponent::DrawSize' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, bManuallyRedraw) == 0x0005B8, "Member 'UWidgetComponent::bManuallyRedraw' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, bRedrawRequested) == 0x0005B9, "Member 'UWidgetComponent::bRedrawRequested' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, RedrawTime) == 0x0005BC, "Member 'UWidgetComponent::RedrawTime' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, CurrentDrawSize) == 0x0005C8, "Member 'UWidgetComponent::CurrentDrawSize' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, bDrawAtDesiredSize) == 0x0005D0, "Member 'UWidgetComponent::bDrawAtDesiredSize' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, Pivot) == 0x0005D4, "Member 'UWidgetComponent::Pivot' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, bReceiveHardwareInput) == 0x0005DC, "Member 'UWidgetComponent::bReceiveHardwareInput' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, bWindowFocusable) == 0x0005DD, "Member 'UWidgetComponent::bWindowFocusable' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, bApplyGammaCorrection) == 0x0005DE, "Member 'UWidgetComponent::bApplyGammaCorrection' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, OwnerPlayer) == 0x0005E0, "Member 'UWidgetComponent::OwnerPlayer' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, BackgroundColor) == 0x0005E8, "Member 'UWidgetComponent::BackgroundColor' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, TintColorAndOpacity) == 0x0005F8, "Member 'UWidgetComponent::TintColorAndOpacity' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, OpacityFromTexture) == 0x000608, "Member 'UWidgetComponent::OpacityFromTexture' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, BlendMode) == 0x00060C, "Member 'UWidgetComponent::BlendMode' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, bIsTwoSided) == 0x00060D, "Member 'UWidgetComponent::bIsTwoSided' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, TickWhenOffscreen) == 0x00060E, "Member 'UWidgetComponent::TickWhenOffscreen' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, Widget) == 0x000610, "Member 'UWidgetComponent::Widget' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, BodySetup) == 0x000638, "Member 'UWidgetComponent::BodySetup' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, TranslucentMaterial) == 0x000640, "Member 'UWidgetComponent::TranslucentMaterial' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, TranslucentMaterial_OneSided) == 0x000648, "Member 'UWidgetComponent::TranslucentMaterial_OneSided' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, OpaqueMaterial) == 0x000650, "Member 'UWidgetComponent::OpaqueMaterial' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, OpaqueMaterial_OneSided) == 0x000658, "Member 'UWidgetComponent::OpaqueMaterial_OneSided' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, MaskedMaterial) == 0x000660, "Member 'UWidgetComponent::MaskedMaterial' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, MaskedMaterial_OneSided) == 0x000668, "Member 'UWidgetComponent::MaskedMaterial_OneSided' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, RenderTarget) == 0x000670, "Member 'UWidgetComponent::RenderTarget' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, MaterialInstance) == 0x000678, "Member 'UWidgetComponent::MaterialInstance' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, bAddedToScreen) == 0x000680, "Member 'UWidgetComponent::bAddedToScreen' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, bEditTimeUsable) == 0x000681, "Member 'UWidgetComponent::bEditTimeUsable' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, SharedLayerName) == 0x000684, "Member 'UWidgetComponent::SharedLayerName' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, LayerZOrder) == 0x00068C, "Member 'UWidgetComponent::LayerZOrder' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, GeometryMode) == 0x000690, "Member 'UWidgetComponent::GeometryMode' has a wrong offset!");
static_assert(offsetof(UWidgetComponent, CylinderArcAngle) == 0x000694, "Member 'UWidgetComponent::CylinderArcAngle' has a wrong offset!");

// Class UMG.WidgetInteractionComponent
// 0x01F8 (0x0440 - 0x0248)
class UWidgetInteractionComponent final : public USceneComponent
{
public:
	UMulticastDelegateProperty_                   OnHoveredWidgetChanged;                            // 0x0248(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_258[0x10];                                     // 0x0258(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         VirtualUserIndex;                                  // 0x0268(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PointerIndex;                                      // 0x026C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECollisionChannel                             TraceChannel;                                      // 0x0270(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_271[0x3];                                      // 0x0271(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InteractionDistance;                               // 0x0274(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EWidgetInteractionSource                      InteractionSource;                                 // 0x0278(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableHitTesting;                                 // 0x0279(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowDebug;                                        // 0x027A(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_27B[0x1];                                      // 0x027B(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FLinearColor                           DebugColor;                                        // 0x027C(0x0010)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_28C[0x7C];                                     // 0x028C(0x007C)(Fixing Size After Last Property [ Dumper-7 ])
	struct FHitResult                             CustomHitResult;                                   // 0x0308(0x0088)(Transient, IsPlainOldData, NoDestructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	struct FVector2D                              LocalHitLocation;                                  // 0x0390(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector2D                              LastLocalHitLocation;                              // 0x0398(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UWidgetComponent*                       HoveredWidgetComponent;                            // 0x03A0(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FHitResult                             LastHitResult;                                     // 0x03A8(0x0088)(Transient, IsPlainOldData, NoDestructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	bool                                          bIsHoveredWidgetInteractable;                      // 0x0430(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsHoveredWidgetFocusable;                         // 0x0431(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsHoveredWidgetHitTestVisible;                    // 0x0432(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_433[0xD];                                      // 0x0433(0x000D)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool PressAndReleaseKey(const struct FKey& Key);
	bool PressKey(const struct FKey& Key, bool bRepeat);
	void PressPointerKey(const struct FKey& Key);
	bool ReleaseKey(const struct FKey& Key);
	void ReleasePointerKey(const struct FKey& Key);
	void ScrollWheel(float ScrollDelta);
	bool SendKeyChar(const class FString& Characters, bool bRepeat);
	void SetCustomHitResult(const struct FHitResult& HitResult);

	struct FVector2D Get2DHitLocation() const;
	class UWidgetComponent* GetHoveredWidgetComponent() const;
	const struct FHitResult GetLastHitResult() const;
	bool IsOverFocusableWidget() const;
	bool IsOverHitTestVisibleWidget() const;
	bool IsOverInteractableWidget() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WidgetInteractionComponent">();
	}
	static class UWidgetInteractionComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWidgetInteractionComponent>();
	}
};
static_assert(alignof(UWidgetInteractionComponent) == 0x000008, "Wrong alignment on UWidgetInteractionComponent");
static_assert(sizeof(UWidgetInteractionComponent) == 0x000440, "Wrong size on UWidgetInteractionComponent");
static_assert(offsetof(UWidgetInteractionComponent, OnHoveredWidgetChanged) == 0x000248, "Member 'UWidgetInteractionComponent::OnHoveredWidgetChanged' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, VirtualUserIndex) == 0x000268, "Member 'UWidgetInteractionComponent::VirtualUserIndex' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, PointerIndex) == 0x00026C, "Member 'UWidgetInteractionComponent::PointerIndex' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, TraceChannel) == 0x000270, "Member 'UWidgetInteractionComponent::TraceChannel' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, InteractionDistance) == 0x000274, "Member 'UWidgetInteractionComponent::InteractionDistance' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, InteractionSource) == 0x000278, "Member 'UWidgetInteractionComponent::InteractionSource' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, bEnableHitTesting) == 0x000279, "Member 'UWidgetInteractionComponent::bEnableHitTesting' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, bShowDebug) == 0x00027A, "Member 'UWidgetInteractionComponent::bShowDebug' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, DebugColor) == 0x00027C, "Member 'UWidgetInteractionComponent::DebugColor' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, CustomHitResult) == 0x000308, "Member 'UWidgetInteractionComponent::CustomHitResult' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, LocalHitLocation) == 0x000390, "Member 'UWidgetInteractionComponent::LocalHitLocation' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, LastLocalHitLocation) == 0x000398, "Member 'UWidgetInteractionComponent::LastLocalHitLocation' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, HoveredWidgetComponent) == 0x0003A0, "Member 'UWidgetInteractionComponent::HoveredWidgetComponent' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, LastHitResult) == 0x0003A8, "Member 'UWidgetInteractionComponent::LastHitResult' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, bIsHoveredWidgetInteractable) == 0x000430, "Member 'UWidgetInteractionComponent::bIsHoveredWidgetInteractable' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, bIsHoveredWidgetFocusable) == 0x000431, "Member 'UWidgetInteractionComponent::bIsHoveredWidgetFocusable' has a wrong offset!");
static_assert(offsetof(UWidgetInteractionComponent, bIsHoveredWidgetHitTestVisible) == 0x000432, "Member 'UWidgetInteractionComponent::bIsHoveredWidgetHitTestVisible' has a wrong offset!");

// Class UMG.WidgetLayoutLibrary
// 0x0000 (0x0028 - 0x0028)
class UWidgetLayoutLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FVector2D GetMousePositionOnPlatform();
	static struct FVector2D GetMousePositionOnViewport(class UObject* WorldContextObject);
	static bool GetMousePositionScaledByDPI(class APlayerController* Player, float* LocationX, float* LocationY);
	static struct FGeometry GetPlayerScreenWidgetGeometry(class APlayerController* PlayerController);
	static float GetViewportScale(class UObject* WorldContextObject);
	static struct FVector2D GetViewportSize(class UObject* WorldContextObject);
	static struct FGeometry GetViewportWidgetGeometry(class UObject* WorldContextObject);
	static bool ProjectWorldLocationToWidgetPosition(class APlayerController* PlayerController, const struct FVector& WorldLocation, struct FVector2D* ScreenPosition);
	static void RemoveAllWidgets(class UObject* WorldContextObject);
	static class UBorderSlot* SlotAsBorderSlot(class UWidget* Widget);
	static class UCanvasPanelSlot* SlotAsCanvasSlot(class UWidget* Widget);
	static class UGridSlot* SlotAsGridSlot(class UWidget* Widget);
	static class UHorizontalBoxSlot* SlotAsHorizontalBoxSlot(class UWidget* Widget);
	static class UOverlaySlot* SlotAsOverlaySlot(class UWidget* Widget);
	static class UUniformGridSlot* SlotAsUniformGridSlot(class UWidget* Widget);
	static class UVerticalBoxSlot* SlotAsVerticalBoxSlot(class UWidget* Widget);

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

// Class UMG.WidgetNavigation
// 0x00D8 (0x0100 - 0x0028)
class UWidgetNavigation final : public UObject
{
public:
	struct FWidgetNavigationData                  Up;                                                // 0x0028(0x0024)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FWidgetNavigationData                  Down;                                              // 0x004C(0x0024)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FWidgetNavigationData                  Left;                                              // 0x0070(0x0024)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FWidgetNavigationData                  Right;                                             // 0x0094(0x0024)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FWidgetNavigationData                  Next;                                              // 0x00B8(0x0024)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FWidgetNavigationData                  Previous;                                          // 0x00DC(0x0024)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WidgetNavigation">();
	}
	static class UWidgetNavigation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWidgetNavigation>();
	}
};
static_assert(alignof(UWidgetNavigation) == 0x000008, "Wrong alignment on UWidgetNavigation");
static_assert(sizeof(UWidgetNavigation) == 0x000100, "Wrong size on UWidgetNavigation");
static_assert(offsetof(UWidgetNavigation, Up) == 0x000028, "Member 'UWidgetNavigation::Up' has a wrong offset!");
static_assert(offsetof(UWidgetNavigation, Down) == 0x00004C, "Member 'UWidgetNavigation::Down' has a wrong offset!");
static_assert(offsetof(UWidgetNavigation, Left) == 0x000070, "Member 'UWidgetNavigation::Left' has a wrong offset!");
static_assert(offsetof(UWidgetNavigation, Right) == 0x000094, "Member 'UWidgetNavigation::Right' has a wrong offset!");
static_assert(offsetof(UWidgetNavigation, Next) == 0x0000B8, "Member 'UWidgetNavigation::Next' has a wrong offset!");
static_assert(offsetof(UWidgetNavigation, Previous) == 0x0000DC, "Member 'UWidgetNavigation::Previous' has a wrong offset!");

// Class UMG.WidgetSwitcherSlot
// 0x0020 (0x0058 - 0x0038)
class UWidgetSwitcherSlot final : public UPanelSlot
{
public:
	struct FMargin                                Padding;                                           // 0x0038(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0048(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0049(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4A[0xE];                                       // 0x004A(0x000E)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

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

// Class UMG.WidgetTree
// 0x0008 (0x0030 - 0x0028)
class UWidgetTree final : public UObject
{
public:
	class UWidget*                                RootWidget;                                        // 0x0028(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

// Class UMG.WindowTitleBarArea
// 0x0020 (0x0140 - 0x0120)
class UWindowTitleBarArea final : public UContentWidget
{
public:
	bool                                          bWindowButtonsEnabled;                             // 0x0120(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDoubleClickTogglesFullscreen;                     // 0x0121(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_122[0x1E];                                     // 0x0122(0x001E)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WindowTitleBarArea">();
	}
	static class UWindowTitleBarArea* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWindowTitleBarArea>();
	}
};
static_assert(alignof(UWindowTitleBarArea) == 0x000008, "Wrong alignment on UWindowTitleBarArea");
static_assert(sizeof(UWindowTitleBarArea) == 0x000140, "Wrong size on UWindowTitleBarArea");
static_assert(offsetof(UWindowTitleBarArea, bWindowButtonsEnabled) == 0x000120, "Member 'UWindowTitleBarArea::bWindowButtonsEnabled' has a wrong offset!");
static_assert(offsetof(UWindowTitleBarArea, bDoubleClickTogglesFullscreen) == 0x000121, "Member 'UWindowTitleBarArea::bDoubleClickTogglesFullscreen' has a wrong offset!");

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

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

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

// Class UMG.WrapBox
// 0x0020 (0x0140 - 0x0120)
class UWrapBox final : public UPanelWidget
{
public:
	struct FVector2D                              InnerSlotPadding;                                  // 0x0120(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WrapWidth;                                         // 0x0128(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bExplicitWrapWidth;                                // 0x012C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12D[0x13];                                     // 0x012D(0x0013)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UWrapBoxSlot* AddChildWrapBox(class UWidget* Content);
	void SetInnerSlotPadding(const struct FVector2D& InPadding);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WrapBox">();
	}
	static class UWrapBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWrapBox>();
	}
};
static_assert(alignof(UWrapBox) == 0x000008, "Wrong alignment on UWrapBox");
static_assert(sizeof(UWrapBox) == 0x000140, "Wrong size on UWrapBox");
static_assert(offsetof(UWrapBox, InnerSlotPadding) == 0x000120, "Member 'UWrapBox::InnerSlotPadding' has a wrong offset!");
static_assert(offsetof(UWrapBox, WrapWidth) == 0x000128, "Member 'UWrapBox::WrapWidth' has a wrong offset!");
static_assert(offsetof(UWrapBox, bExplicitWrapWidth) == 0x00012C, "Member 'UWrapBox::bExplicitWrapWidth' has a wrong offset!");

// Class UMG.WrapBoxSlot
// 0x0028 (0x0060 - 0x0038)
class UWrapBoxSlot final : public UPanelSlot
{
public:
	struct FMargin                                Padding;                                           // 0x0038(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bFillEmptySpace;                                   // 0x0048(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x3];                                       // 0x0049(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         FillSpanWhenLessThan;                              // 0x004C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EHorizontalAlignment                          HorizontalAlignment;                               // 0x0050(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalAlignment                            VerticalAlignment;                                 // 0x0051(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_52[0xE];                                       // 0x0052(0x000E)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetFillEmptySpace(bool InbFillEmptySpace);
	void SetFillSpanWhenLessThan(float InFillSpanWhenLessThan);
	void SetHorizontalAlignment(EHorizontalAlignment InHorizontalAlignment);
	void SetPadding(const struct FMargin& InPadding);
	void SetVerticalAlignment(EVerticalAlignment InVerticalAlignment);

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

}

