#pragma once

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

// Package: FortniteUI

#include "Basic.hpp"

#include "FortniteUI_classes.hpp"
#include "FortniteUI_parameters.hpp"


#pragma pack(push, 0x4)
namespace SDK
{

// Function FortniteUI.FortAbstractButtonGroup.HandleButtonClicked
// (Native, Public, BlueprintCallable)
// Parameters:
// class UFortButton*                      Button                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAbstractButtonGroup::HandleButtonClicked(class UFortButton* Button)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbstractButtonGroup", "HandleButtonClicked");

	Params::FortAbstractButtonGroup_HandleButtonClicked Parms{};

	Parms.Button = Button;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortAbstractButtonGroup.SetDataProvider
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class FText>&              InDataProvider                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UFortAbstractButtonGroup::SetDataProvider(const TArray<class FText>& InDataProvider)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbstractButtonGroup", "SetDataProvider");

	Params::FortAbstractButtonGroup_SetDataProvider Parms{};

	Parms.InDataProvider = std::move(InDataProvider);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortTabButtonGroup.GetTabButton
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortTabButton*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortTabButton* UFortTabButtonGroup::GetTabButton(int32 INDEX)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTabButtonGroup", "GetTabButton");

	Params::FortTabButtonGroup_GetTabButton Parms{};

	Parms.INDEX = INDEX;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortTabButtonGroup.SetInitialButtonSelection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTabButtonGroup::SetInitialButtonSelection(int32 INDEX)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTabButtonGroup", "SetInitialButtonSelection");

	Params::FortTabButtonGroup_SetInitialButtonSelection Parms{};

	Parms.INDEX = INDEX;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortActorCanvas.AddActorIndicator
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortActorIndicatorWidget*        Indicator                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortActorCanvasSlot*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortActorCanvasSlot* UFortActorCanvas::AddActorIndicator(class UFortActorIndicatorWidget* Indicator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActorCanvas", "AddActorIndicator");

	Params::FortActorCanvas_AddActorIndicator Parms{};

	Parms.Indicator = Indicator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortActorCanvasSlot.SetCanAutoRemove
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bAllowAutoRemove                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortActorCanvasSlot::SetCanAutoRemove(bool bAllowAutoRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActorCanvasSlot", "SetCanAutoRemove");

	Params::FortActorCanvasSlot_SetCanAutoRemove Parms{};

	Parms.bAllowAutoRemove = bAllowAutoRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortActorCanvasSlot.SetHorizontalAlignment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EHorizontalAlignment                    InHorizontalAlignment                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortActorCanvasSlot::SetHorizontalAlignment(EHorizontalAlignment InHorizontalAlignment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActorCanvasSlot", "SetHorizontalAlignment");

	Params::FortActorCanvasSlot_SetHorizontalAlignment Parms{};

	Parms.InHorizontalAlignment = InHorizontalAlignment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortActorCanvasSlot.SetVerticalAlignment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EVerticalAlignment                      InVerticalAlignment                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortActorCanvasSlot::SetVerticalAlignment(EVerticalAlignment InVerticalAlignment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActorCanvasSlot", "SetVerticalAlignment");

	Params::FortActorCanvasSlot_SetVerticalAlignment Parms{};

	Parms.InVerticalAlignment = InVerticalAlignment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortAsyncAction_SetUIState.SetUIState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContextObject                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortUIState                            DesiredState                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAsyncAction_SetUIState*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAsyncAction_SetUIState* UFortAsyncAction_SetUIState::SetUIState(class UObject* InWorldContextObject, EFortUIState DesiredState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAsyncAction_SetUIState", "SetUIState");

	Params::FortAsyncAction_SetUIState_SetUIState Parms{};

	Parms.InWorldContextObject = InWorldContextObject;
	Parms.DesiredState = DesiredState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortAsyncAction_ShowConfirmation.ShowConfirmationDialog
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContextObject                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      Title                                                  (Parm, NativeAccessSpecifierPublic)
// const class FText&                      Message                                                (Parm, NativeAccessSpecifierPublic)
// const class FText&                      ConfirmButtonText                                      (Parm, NativeAccessSpecifierPublic)
// const class FText&                      DeclineButtonText                                      (Parm, NativeAccessSpecifierPublic)
// class UFortUserWidget*                  InAdditionalContent                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InDisplayTime                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAsyncAction_ShowConfirmation*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAsyncAction_ShowConfirmation* UFortAsyncAction_ShowConfirmation::ShowConfirmationDialog(class UObject* InWorldContextObject, const class FText& Title, const class FText& Message, const class FText& ConfirmButtonText, const class FText& DeclineButtonText, class UFortUserWidget* InAdditionalContent, float InDisplayTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAsyncAction_ShowConfirmation", "ShowConfirmationDialog");

	Params::FortAsyncAction_ShowConfirmation_ShowConfirmationDialog Parms{};

	Parms.InWorldContextObject = InWorldContextObject;
	Parms.Title = std::move(Title);
	Parms.Message = std::move(Message);
	Parms.ConfirmButtonText = std::move(ConfirmButtonText);
	Parms.DeclineButtonText = std::move(DeclineButtonText);
	Parms.InAdditionalContent = InAdditionalContent;
	Parms.InDisplayTime = InDisplayTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortBangWrapper.SetBangVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InVisible                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortBangWrapper::SetBangVisibility(bool InVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBangWrapper", "SetBangVisibility");

	Params::FortBangWrapper_SetBangVisibility Parms{};

	Parms.InVisible = InVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUserWidget._BPInvalidate
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class FName                             Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUserWidget::_BPInvalidate(class FName Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUserWidget", "_BPInvalidate");

	Params::FortUserWidget__BPInvalidate Parms{};

	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUserWidget.DispatchEvent
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUserWidget::DispatchEvent(class FName EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUserWidget", "DispatchEvent");

	Params::FortUserWidget_DispatchEvent Parms{};

	Parms.EventName = EventName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUserWidget.PreConstruct
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    IsDesignTime                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortUserWidget::PreConstruct(bool IsDesignTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUserWidget", "PreConstruct");

	Params::FortUserWidget_PreConstruct Parms{};

	Parms.IsDesignTime = IsDesignTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortUserWidget.RegisterForEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TDelegate<void(class UFortUserWidget* InWidget)>InCallback                                             (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UFortUserWidget::RegisterForEvent(class FName EventName, TDelegate<void(class UFortUserWidget* InWidget)> InCallback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUserWidget", "RegisterForEvent");

	Params::FortUserWidget_RegisterForEvent Parms{};

	Parms.EventName = EventName;
	Parms.InCallback = InCallback;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUserWidget.RegisterForInvalidation
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class FName                             InvalidationType                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TDelegate<void()>                       Callback                                               (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UFortUserWidget::RegisterForInvalidation(class FName InvalidationType, TDelegate<void()> Callback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUserWidget", "RegisterForInvalidation");

	Params::FortUserWidget_RegisterForInvalidation Parms{};

	Parms.InvalidationType = InvalidationType;
	Parms.Callback = Callback;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUserWidget.UnregisterForEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TDelegate<void(class UFortUserWidget* InWidget)>InCallback                                             (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UFortUserWidget::UnregisterForEvent(class FName EventName, TDelegate<void(class UFortUserWidget* InWidget)> InCallback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUserWidget", "UnregisterForEvent");

	Params::FortUserWidget_UnregisterForEvent Parms{};

	Parms.EventName = EventName;
	Parms.InCallback = InCallback;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUserWidget.IsInvalid
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortUserWidget::IsInvalid(class FName Type) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUserWidget", "IsInvalid");

	Params::FortUserWidget_IsInvalid Parms{};

	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButtonStyle.GetBrushBySizeFromMultiSizeBrush
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortMultiSizeBrush&       MultiSizeBrush                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// EFortBrushSize                          Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSlateBrush                ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FSlateBrush UFortButtonStyle::GetBrushBySizeFromMultiSizeBrush(const struct FFortMultiSizeBrush& MultiSizeBrush, EFortBrushSize Size)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortButtonStyle", "GetBrushBySizeFromMultiSizeBrush");

	Params::FortButtonStyle_GetBrushBySizeFromMultiSizeBrush Parms{};

	Parms.MultiSizeBrush = std::move(MultiSizeBrush);
	Parms.Size = Size;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButtonStyle.GetFontBySizeFromMultiSizeFont
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortMultiSizeFont&        MultiSizeFont                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// EFortBrushSize                          Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSlateFontInfo             ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FSlateFontInfo UFortButtonStyle::GetFontBySizeFromMultiSizeFont(const struct FFortMultiSizeFont& MultiSizeFont, EFortBrushSize Size)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortButtonStyle", "GetFontBySizeFromMultiSizeFont");

	Params::FortButtonStyle_GetFontBySizeFromMultiSizeFont Parms{};

	Parms.MultiSizeFont = std::move(MultiSizeFont);
	Parms.Size = Size;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButtonStyle.GetMarginBySizeFromMultiSizeMargin
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortMultiSizeMargin&      MultiSizeMargin                                        (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// EFortBrushSize                          Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMargin                    ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FMargin UFortButtonStyle::GetMarginBySizeFromMultiSizeMargin(const struct FFortMultiSizeMargin& MultiSizeMargin, EFortBrushSize Size)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortButtonStyle", "GetMarginBySizeFromMultiSizeMargin");

	Params::FortButtonStyle_GetMarginBySizeFromMultiSizeMargin Parms{};

	Parms.MultiSizeMargin = std::move(MultiSizeMargin);
	Parms.Size = Size;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButtonStyle.GetButtonPaddingBySize
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortBrushSize                          Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMargin                    ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FMargin UFortButtonStyle::GetButtonPaddingBySize(EFortBrushSize Size) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButtonStyle", "GetButtonPaddingBySize");

	Params::FortButtonStyle_GetButtonPaddingBySize Parms{};

	Parms.Size = Size;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButtonStyle.GetCustomPaddingBySize
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortBrushSize                          Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMargin                    ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FMargin UFortButtonStyle::GetCustomPaddingBySize(EFortBrushSize Size) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButtonStyle", "GetCustomPaddingBySize");

	Params::FortButtonStyle_GetCustomPaddingBySize Parms{};

	Parms.Size = Size;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButtonStyle.GetFontBySize
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortBrushSize                          Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSlateFontInfo             ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FSlateFontInfo UFortButtonStyle::GetFontBySize(EFortBrushSize Size) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButtonStyle", "GetFontBySize");

	Params::FortButtonStyle_GetFontBySize Parms{};

	Parms.Size = Size;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortBaseButton.ForceClick
// (Final, Native, Public, BlueprintCallable)

void UFortBaseButton::ForceClick()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "ForceClick");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.GetSelectionGroupIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortBaseButton::GetSelectionGroupIndex()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "GetSelectionGroupIndex");

	Params::FortBaseButton_GetSelectionGroupIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortBaseButton.OnButtonClicked
// (Final, Native, Protected)

void UFortBaseButton::OnButtonClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "OnButtonClicked");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.SetBangVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortBaseButton::SetBangVisibility(bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "SetBangVisibility");

	Params::FortBaseButton_SetBangVisibility Parms{};

	Parms.bVisible = bVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.SetBrushSize
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortBrushSize                          InSize                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBaseButton::SetBrushSize(EFortBrushSize InSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "SetBrushSize");

	Params::FortBaseButton_SetBrushSize Parms{};

	Parms.InSize = InSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.SetClickable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InClickable                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortBaseButton::SetClickable(bool InClickable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "SetClickable");

	Params::FortBaseButton_SetClickable Parms{};

	Parms.InClickable = InClickable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.SetClickMethod
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EButtonClickMethod                      InClickMethod                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBaseButton::SetClickMethod(EButtonClickMethod InClickMethod)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "SetClickMethod");

	Params::FortBaseButton_SetClickMethod Parms{};

	Parms.InClickMethod = InClickMethod;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.SetHovered
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InHovered                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortBaseButton::SetHovered(bool InHovered)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "SetHovered");

	Params::FortBaseButton_SetHovered Parms{};

	Parms.InHovered = InHovered;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.SetSelected
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InSelected                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortBaseButton::SetSelected(bool InSelected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "SetSelected");

	Params::FortBaseButton_SetSelected Parms{};

	Parms.InSelected = InSelected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.SetSelectionGroup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             InSelectionGroup                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBaseButton::SetSelectionGroup(class FName InSelectionGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "SetSelectionGroup");

	Params::FortBaseButton_SetSelectionGroup Parms{};

	Parms.InSelectionGroup = InSelectionGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.SetStyle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UFortButtonStyle>     InStyle                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBaseButton::SetStyle(TSubclassOf<class UFortButtonStyle> InStyle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "SetStyle");

	Params::FortBaseButton_SetStyle Parms{};

	Parms.InStyle = InStyle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortBaseButton.GetCurrentButtonPadding
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FMargin                    ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FMargin UFortBaseButton::GetCurrentButtonPadding() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "GetCurrentButtonPadding");

	Params::FortBaseButton_GetCurrentButtonPadding Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortBaseButton.GetCurrentCustomPadding
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FMargin                    ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FMargin UFortBaseButton::GetCurrentCustomPadding() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "GetCurrentCustomPadding");

	Params::FortBaseButton_GetCurrentCustomPadding Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortBaseButton.GetCurrentFont
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FSlateFontInfo             ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FSlateFontInfo UFortBaseButton::GetCurrentFont() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "GetCurrentFont");

	Params::FortBaseButton_GetCurrentFont Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortBaseButton.GetCurrentStateStyle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortStateStyle            ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FFortStateStyle UFortBaseButton::GetCurrentStateStyle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "GetCurrentStateStyle");

	Params::FortBaseButton_GetCurrentStateStyle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortBaseButton.GetSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortBaseButton::GetSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "GetSelected");

	Params::FortBaseButton_GetSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortBaseButton.GetStyle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortButtonStyle*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortButtonStyle* UFortBaseButton::GetStyle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBaseButton", "GetStyle");

	Params::FortBaseButton_GetStyle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.BindToFeatureStateAndInitialize
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortFrontEndFeature                    Feature                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TDelegate<void(EFortFrontEndFeature ChangedFeature, EFortFrontEndFeatureState NewState)>Delegate                                               (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UFortFrontEndContext::BindToFeatureStateAndInitialize(EFortFrontEndFeature Feature, TDelegate<void(EFortFrontEndFeature ChangedFeature, EFortFrontEndFeatureState NewState)> Delegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "BindToFeatureStateAndInitialize");

	Params::FortFrontEndContext_BindToFeatureStateAndInitialize Parms{};

	Parms.Feature = Feature;
	Parms.Delegate = Delegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.ClearNativeWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UNativeWidgetHost*                InNativeWidgetHost                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::ClearNativeWidget(class UNativeWidgetHost* InNativeWidgetHost)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "ClearNativeWidget");

	Params::FortFrontEndContext_ClearNativeWidget Parms{};

	Parms.InNativeWidgetHost = InNativeWidgetHost;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.ClearSelectedTheater
// (Final, Native, Public, BlueprintCallable)

void UFortFrontEndContext::ClearSelectedTheater()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "ClearSelectedTheater");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.ForceSetFeatureState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortFrontEndFeature                    Feature                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortFrontEndFeatureState               State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::ForceSetFeatureState(EFortFrontEndFeature Feature, EFortFrontEndFeatureState State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "ForceSetFeatureState");

	Params::FortFrontEndContext_ForceSetFeatureState Parms{};

	Parms.Feature = Feature;
	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.GetAttributeDescription
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAttributeInfo&        InAttribute                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     InRequiredTags                                         (Parm, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortFrontEndContext::GetAttributeDescription(const struct FFortAttributeInfo& InAttribute, const struct FGameplayTagContainer& InRequiredTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetAttributeDescription");

	Params::FortFrontEndContext_GetAttributeDescription Parms{};

	Parms.InAttribute = std::move(InAttribute);
	Parms.InRequiredTags = std::move(InRequiredTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetAttributeDisplayName
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAttributeInfo&        InAttribute                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     InRequiredTags                                         (Parm, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortFrontEndContext::GetAttributeDisplayName(const struct FFortAttributeInfo& InAttribute, const struct FGameplayTagContainer& InRequiredTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetAttributeDisplayName");

	Params::FortFrontEndContext_GetAttributeDisplayName Parms{};

	Parms.InAttribute = std::move(InAttribute);
	Parms.InRequiredTags = std::move(InRequiredTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetAttributeIcon
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAttributeInfo&        InAttribute                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     InRequiredTags                                         (Parm, NativeAccessSpecifierPublic)
// struct FFortMultiSizeBrush              ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortMultiSizeBrush UFortFrontEndContext::GetAttributeIcon(const struct FFortAttributeInfo& InAttribute, const struct FGameplayTagContainer& InRequiredTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetAttributeIcon");

	Params::FortFrontEndContext_GetAttributeIcon Parms{};

	Parms.InAttribute = std::move(InAttribute);
	Parms.InRequiredTags = std::move(InRequiredTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetHeroPlayerPawnByIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   PartyMemberIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlayerPawn* UFortFrontEndContext::GetHeroPlayerPawnByIndex(int32 PartyMemberIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetHeroPlayerPawnByIndex");

	Params::FortFrontEndContext_GetHeroPlayerPawnByIndex Parms{};

	Parms.PartyMemberIndex = PartyMemberIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetPersistentResourceItemDefinition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortPersistentResources                ResourceType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortPersistentResourceItemDefinition*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortPersistentResourceItemDefinition* UFortFrontEndContext::GetPersistentResourceItemDefinition(EFortPersistentResources ResourceType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetPersistentResourceItemDefinition");

	Params::FortFrontEndContext_GetPersistentResourceItemDefinition Parms{};

	Parms.ResourceType = ResourceType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetSelectableGadgets
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<class UFortWorldItem*>*          SelectableGadgets                                      (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<class UFortWorldItem*>*          LastSelectedGadgets                                    (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortFrontEndContext::GetSelectableGadgets(TArray<class UFortWorldItem*>* SelectableGadgets, TArray<class UFortWorldItem*>* LastSelectedGadgets)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetSelectableGadgets");

	Params::FortFrontEndContext_GetSelectableGadgets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (SelectableGadgets != nullptr)
		*SelectableGadgets = std::move(Parms.SelectableGadgets);

	if (LastSelectedGadgets != nullptr)
		*LastSelectedGadgets = std::move(Parms.LastSelectedGadgets);
}


// Function FortniteUI.FortFrontEndContext.IsActiveTileMissionValid
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortFrontEndContext::IsActiveTileMissionValid()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "IsActiveTileMissionValid");

	Params::FortFrontEndContext_IsActiveTileMissionValid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.LoadOutpostView
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortFrontEndContext::LoadOutpostView(int32 TheaterSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "LoadOutpostView");

	Params::FortFrontEndContext_LoadOutpostView Parms{};

	Parms.TheaterSlot = TheaterSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.MarkSeenItemsInVault
// (Final, Native, Public, BlueprintCallable)

void UFortFrontEndContext::MarkSeenItemsInVault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "MarkSeenItemsInVault");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.NotifyCreateBuildingClosed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UHomeBaseBuilding*                Building                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::NotifyCreateBuildingClosed(class UHomeBaseBuilding* Building)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "NotifyCreateBuildingClosed");

	Params::FortFrontEndContext_NotifyCreateBuildingClosed Parms{};

	Parms.Building = Building;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.RunBenchmarkAndApplyBestSettings
// (Final, Native, Public, BlueprintCallable)

void UFortFrontEndContext::RunBenchmarkAndApplyBestSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "RunBenchmarkAndApplyBestSettings");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.SelectDefaultTheaterTile
// (Final, Native, Public, BlueprintCallable)

void UFortFrontEndContext::SelectDefaultTheaterTile()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "SelectDefaultTheaterTile");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.SelectGadgetForSlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortItemDefinition*              GadgetDefinition                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::SelectGadgetForSlot(int32 Slot, class UFortItemDefinition* GadgetDefinition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "SelectGadgetForSlot");

	Params::FortFrontEndContext_SelectGadgetForSlot Parms{};

	Parms.Slot = Slot;
	Parms.GadgetDefinition = GadgetDefinition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.SetFrontEndCamera
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFrontEndCamera                         NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::SetFrontEndCamera(EFrontEndCamera NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "SetFrontEndCamera");

	Params::FortFrontEndContext_SetFrontEndCamera Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.SetHeroChoice
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   PartyMemberIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortHero*                        Hero                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::SetHeroChoice(int32 PartyMemberIndex, class UFortHero* Hero)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "SetHeroChoice");

	Params::FortFrontEndContext_SetHeroChoice Parms{};

	Parms.PartyMemberIndex = PartyMemberIndex;
	Parms.Hero = Hero;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.SetPersonalHeroChoice
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortHero*                        Hero                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::SetPersonalHeroChoice(class UFortHero* Hero)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "SetPersonalHeroChoice");

	Params::FortFrontEndContext_SetPersonalHeroChoice Parms{};

	Parms.Hero = Hero;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.SetSelectedTheater
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   TheaterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::SetSelectedTheater(int32 TheaterIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "SetSelectedTheater");

	Params::FortFrontEndContext_SetSelectedTheater Parms{};

	Parms.TheaterIndex = TheaterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.SkipInitialBenchmark
// (Final, Native, Public, BlueprintCallable)

void UFortFrontEndContext::SkipInitialBenchmark()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "SkipInitialBenchmark");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.ViewVaultItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortItem*                        ItemToView                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::ViewVaultItem(class UFortItem* ItemToView)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "ViewVaultItem");

	Params::FortFrontEndContext_ViewVaultItem Parms{};

	Parms.ItemToView = ItemToView;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.CreateKeepMenu
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class UNativeWidgetHost*                InNativeWidgetHost                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UHomeBaseBuilding*                Building                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::CreateKeepMenu(class UNativeWidgetHost* InNativeWidgetHost, class UHomeBaseBuilding* Building) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "CreateKeepMenu");

	Params::FortFrontEndContext_CreateKeepMenu Parms{};

	Parms.InNativeWidgetHost = InNativeWidgetHost;
	Parms.Building = Building;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortFrontEndContext.GetAccountLevelUpRewards
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FFortItemQuantityPair>*   Rewards                                                (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   AccountLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::GetAccountLevelUpRewards(TArray<struct FFortItemQuantityPair>* Rewards, int32 AccountLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetAccountLevelUpRewards");

	Params::FortFrontEndContext_GetAccountLevelUpRewards Parms{};

	Parms.AccountLevel = AccountLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Rewards != nullptr)
		*Rewards = std::move(Parms.Rewards);
}


// Function FortniteUI.FortFrontEndContext.GetActiveTile
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortTheaterMapTile*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortTheaterMapTile* UFortFrontEndContext::GetActiveTile() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetActiveTile");

	Params::FortFrontEndContext_GetActiveTile Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetActiveTileMissionDetails
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFortMissionDetails*             MissionDetails                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortFrontEndContext::GetActiveTileMissionDetails(struct FFortMissionDetails* MissionDetails) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetActiveTileMissionDetails");

	Params::FortFrontEndContext_GetActiveTileMissionDetails Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (MissionDetails != nullptr)
		*MissionDetails = std::move(Parms.MissionDetails);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetAllTheaterData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FFortTheaterMapData>*     OutAllTheaterData                                      (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortFrontEndContext::GetAllTheaterData(TArray<struct FFortTheaterMapData>* OutAllTheaterData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetAllTheaterData");

	Params::FortFrontEndContext_GetAllTheaterData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutAllTheaterData != nullptr)
		*OutAllTheaterData = std::move(Parms.OutAllTheaterData);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetAvailibleDifficulties
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FGameDifficultyInfo>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FGameDifficultyInfo> UFortFrontEndContext::GetAvailibleDifficulties() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetAvailibleDifficulties");

	Params::FortFrontEndContext_GetAvailibleDifficulties Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetCurrentTheaterName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortFrontEndContext::GetCurrentTheaterName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetCurrentTheaterName");

	Params::FortFrontEndContext_GetCurrentTheaterName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetDesiredPlayButtonCamera
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFrontEndCamera                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFrontEndCamera UFortFrontEndContext::GetDesiredPlayButtonCamera() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetDesiredPlayButtonCamera");

	Params::FortFrontEndContext_GetDesiredPlayButtonCamera Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetFabricatorDisintegrationSecondsRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetFabricatorDisintegrationSecondsRemaining(int32 TheaterSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetFabricatorDisintegrationSecondsRemaining");

	Params::FortFrontEndContext_GetFabricatorDisintegrationSecondsRemaining Parms{};

	Parms.TheaterSlot = TheaterSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetFabricatorIncomingGooAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetFabricatorIncomingGooAmount(int32 TheaterSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetFabricatorIncomingGooAmount");

	Params::FortFrontEndContext_GetFabricatorIncomingGooAmount Parms{};

	Parms.TheaterSlot = TheaterSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetFabricatorMaxCapacity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetFabricatorMaxCapacity(int32 TheaterSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetFabricatorMaxCapacity");

	Params::FortFrontEndContext_GetFabricatorMaxCapacity Parms{};

	Parms.TheaterSlot = TheaterSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetFabricatorStoredGooAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetFabricatorStoredGooAmount(int32 TheaterSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetFabricatorStoredGooAmount");

	Params::FortFrontEndContext_GetFabricatorStoredGooAmount Parms{};

	Parms.TheaterSlot = TheaterSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetFeatureState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortFrontEndFeature                    Feature                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortFrontEndFeatureState               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortFrontEndFeatureState UFortFrontEndContext::GetFeatureState(EFortFrontEndFeature Feature) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetFeatureState");

	Params::FortFrontEndContext_GetFeatureState Parms{};

	Parms.Feature = Feature;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetFrontEndCamera
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFrontEndCamera                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFrontEndCamera UFortFrontEndContext::GetFrontEndCamera() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetFrontEndCamera");

	Params::FortFrontEndContext_GetFrontEndCamera Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetHarvestingToolForLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InHarvestingOptimizerLevel                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItemDefinition*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortWorldItemDefinition* UFortFrontEndContext::GetHarvestingToolForLevel(int32 TheaterSlot, int32 InHarvestingOptimizerLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetHarvestingToolForLevel");

	Params::FortFrontEndContext_GetHarvestingToolForLevel Parms{};

	Parms.TheaterSlot = TheaterSlot;
	Parms.InHarvestingOptimizerLevel = InHarvestingOptimizerLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetItemFromItemQuantityPair
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortItemQuantityPair&     InPair                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class UFortItemDefinition*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortItemDefinition* UFortFrontEndContext::GetItemFromItemQuantityPair(const struct FFortItemQuantityPair& InPair) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetItemFromItemQuantityPair");

	Params::FortFrontEndContext_GetItemFromItemQuantityPair Parms{};

	Parms.InPair = std::move(InPair);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetMaxNumberOfItemsInStorageVault
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetMaxNumberOfItemsInStorageVault(int32 TheaterSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetMaxNumberOfItemsInStorageVault");

	Params::FortFrontEndContext_GetMaxNumberOfItemsInStorageVault Parms{};

	Parms.TheaterSlot = TheaterSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetNumberOfItemsInStorageVault
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetNumberOfItemsInStorageVault(int32 TheaterSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetNumberOfItemsInStorageVault");

	Params::FortFrontEndContext_GetNumberOfItemsInStorageVault Parms{};

	Parms.TheaterSlot = TheaterSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetOutpostStructureLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetOutpostStructureLevel(int32 TheaterSlot, class UFortOutpostItemDefinition* OutpostStructure) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetOutpostStructureLevel");

	Params::FortFrontEndContext_GetOutpostStructureLevel Parms{};

	Parms.TheaterSlot = TheaterSlot;
	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetOutpostStructureMaxLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetOutpostStructureMaxLevel(int32 TheaterSlot, class UFortOutpostItemDefinition* OutpostStructure) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetOutpostStructureMaxLevel");

	Params::FortFrontEndContext_GetOutpostStructureMaxLevel Parms{};

	Parms.TheaterSlot = TheaterSlot;
	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetOutpostStructureUpgradeCost
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UpgradeLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FFortItemQuantityPair>*   OutWorldItems                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<struct FFortItemQuantityPair>*   OutAccountItems                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortFrontEndContext::GetOutpostStructureUpgradeCost(int32 TheaterSlot, int32 UpgradeLevel, class UFortOutpostItemDefinition* OutpostStructure, TArray<struct FFortItemQuantityPair>* OutWorldItems, TArray<struct FFortItemQuantityPair>* OutAccountItems) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetOutpostStructureUpgradeCost");

	Params::FortFrontEndContext_GetOutpostStructureUpgradeCost Parms{};

	Parms.TheaterSlot = TheaterSlot;
	Parms.UpgradeLevel = UpgradeLevel;
	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutWorldItems != nullptr)
		*OutWorldItems = std::move(Parms.OutWorldItems);

	if (OutAccountItems != nullptr)
		*OutAccountItems = std::move(Parms.OutAccountItems);
}


// Function FortniteUI.FortFrontEndContext.GetPersonnelResourceItemDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortPersistentResourceItemDefinition*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortPersistentResourceItemDefinition* UFortFrontEndContext::GetPersonnelResourceItemDefinition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetPersonnelResourceItemDefinition");

	Params::FortFrontEndContext_GetPersonnelResourceItemDefinition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetPersonnelXpResourceBrush
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FSlateBrush                      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FSlateBrush UFortFrontEndContext::GetPersonnelXpResourceBrush() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetPersonnelXpResourceBrush");

	Params::FortFrontEndContext_GetPersonnelXpResourceBrush Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetRequirementText
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortRequirementsInfo&     InRequirements                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortFrontEndContext::GetRequirementText(const struct FFortRequirementsInfo& InRequirements) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetRequirementText");

	Params::FortFrontEndContext_GetRequirementText Parms{};

	Parms.InRequirements = std::move(InRequirements);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetSchematicResourceItemDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortPersistentResourceItemDefinition*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortPersistentResourceItemDefinition* UFortFrontEndContext::GetSchematicResourceItemDefinition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetSchematicResourceItemDefinition");

	Params::FortFrontEndContext_GetSchematicResourceItemDefinition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetSchematicXpResourceBrush
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FSlateBrush                      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FSlateBrush UFortFrontEndContext::GetSchematicXpResourceBrush() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetSchematicXpResourceBrush");

	Params::FortFrontEndContext_GetSchematicXpResourceBrush Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetSelectedTheaterData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFortTheaterMapData*             OutTheaterData                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortFrontEndContext::GetSelectedTheaterData(struct FFortTheaterMapData* OutTheaterData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetSelectedTheaterData");

	Params::FortFrontEndContext_GetSelectedTheaterData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutTheaterData != nullptr)
		*OutTheaterData = std::move(Parms.OutTheaterData);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetSelectedTheaterIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetSelectedTheaterIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetSelectedTheaterIndex");

	Params::FortFrontEndContext_GetSelectedTheaterIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetTheaterData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFortTheaterMapData*             OutTheaterData                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortFrontEndContext::GetTheaterData(int32 TheaterIndex, struct FFortTheaterMapData* OutTheaterData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetTheaterData");

	Params::FortFrontEndContext_GetTheaterData Parms{};

	Parms.TheaterIndex = TheaterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutTheaterData != nullptr)
		*OutTheaterData = std::move(Parms.OutTheaterData);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetTheaterDifficultyText
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortFrontEndContext::GetTheaterDifficultyText(int32 TheaterIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetTheaterDifficultyText");

	Params::FortFrontEndContext_GetTheaterDifficultyText Parms{};

	Parms.TheaterIndex = TheaterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetTheaterName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortFrontEndContext::GetTheaterName(int32 TheaterIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetTheaterName");

	Params::FortFrontEndContext_GetTheaterName Parms{};

	Parms.TheaterIndex = TheaterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetTheaterRegionCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortFrontEndContext::GetTheaterRegionCount(int32 TheaterIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetTheaterRegionCount");

	Params::FortFrontEndContext_GetTheaterRegionCount Parms{};

	Parms.TheaterIndex = TheaterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetTheaterType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTheaterType                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortTheaterType UFortFrontEndContext::GetTheaterType(int32 TheaterIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetTheaterType");

	Params::FortFrontEndContext_GetTheaterType Parms{};

	Parms.TheaterIndex = TheaterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.GetTileMissionDetails
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AFortTheaterMapTile*        Tile                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFortMissionDetails*             MissionDetails                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortFrontEndContext::GetTileMissionDetails(const class AFortTheaterMapTile* Tile, struct FFortMissionDetails* MissionDetails) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "GetTileMissionDetails");

	Params::FortFrontEndContext_GetTileMissionDetails Parms{};

	Parms.Tile = Tile;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (MissionDetails != nullptr)
		*MissionDetails = std::move(Parms.MissionDetails);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.IsFabricatorDisintegrating
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TheaterSlot                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortFrontEndContext::IsFabricatorDisintegrating(int32 TheaterSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "IsFabricatorDisintegrating");

	Params::FortFrontEndContext_IsFabricatorDisintegrating Parms{};

	Parms.TheaterSlot = TheaterSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.ShouldRunInitialBenchmark
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortFrontEndContext::ShouldRunInitialBenchmark() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "ShouldRunInitialBenchmark");

	Params::FortFrontEndContext_ShouldRunInitialBenchmark Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortFrontEndContext.TriggerUIFeedbackEvent
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortFrontEndContext::TriggerUIFeedbackEvent(class FName EventName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndContext", "TriggerUIFeedbackEvent");

	Params::FortFrontEndContext_TriggerUIFeedbackEvent Parms{};

	Parms.EventName = EventName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.CheckFlag
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    FlagName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFlagStatus*                            OutStatus                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::CheckFlag(const class FString& FlagName, EFlagStatus* OutStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortGlobalUIContext", "CheckFlag");

	Params::FortGlobalUIContext_CheckFlag Parms{};

	Parms.FlagName = std::move(FlagName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutStatus != nullptr)
		*OutStatus = Parms.OutStatus;
}


// Function FortniteUI.FortGlobalUIContext.BindToFeatureStateAndInitialize
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortUIFeature                          Feature                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TDelegate<void(EFortUIFeature ChangedFeature, EFortUIFeatureState NewState)>Delegate                                               (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::BindToFeatureStateAndInitialize(EFortUIFeature Feature, TDelegate<void(EFortUIFeature ChangedFeature, EFortUIFeatureState NewState)> Delegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "BindToFeatureStateAndInitialize");

	Params::FortGlobalUIContext_BindToFeatureStateAndInitialize Parms{};

	Parms.Feature = Feature;
	Parms.Delegate = Delegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.CheckNetworkError
// (Final, Native, Public, BlueprintCallable)

void UFortGlobalUIContext::CheckNetworkError()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "CheckNetworkError");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.ClearSelectionGroup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             SelectionGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::ClearSelectionGroup(class FName SelectionGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "ClearSelectionGroup");

	Params::FortGlobalUIContext_ClearSelectionGroup Parms{};

	Parms.SelectionGroup = SelectionGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.DisplayStateContent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bDisplay                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::DisplayStateContent(bool bDisplay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "DisplayStateContent");

	Params::FortGlobalUIContext_DisplayStateContent Parms{};

	Parms.bDisplay = bDisplay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.GetBackendName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UFortGlobalUIContext::GetBackendName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetBackendName");

	Params::FortGlobalUIContext_GetBackendName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetGameBackendVersion
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FFortBackendVersion              ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortBackendVersion UFortGlobalUIContext::GetGameBackendVersion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetGameBackendVersion");

	Params::FortGlobalUIContext_GetGameBackendVersion Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetMessageManager
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class FName                             ManagerName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bCreatedNew                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortUIMessageManager*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortUIMessageManager* UFortGlobalUIContext::GetMessageManager(class FName ManagerName, bool* bCreatedNew)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetMessageManager");

	Params::FortGlobalUIContext_GetMessageManager Parms{};

	Parms.ManagerName = ManagerName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bCreatedNew != nullptr)
		*bCreatedNew = Parms.bCreatedNew;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetNextNotification
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FFortDialogDescription*          NotifcationDescription                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGlobalUIContext::GetNextNotification(struct FFortDialogDescription* NotifcationDescription)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetNextNotification");

	Params::FortGlobalUIContext_GetNextNotification Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (NotifcationDescription != nullptr)
		*NotifcationDescription = std::move(Parms.NotifcationDescription);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetWatermark
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UFortGlobalUIContext::GetWatermark()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetWatermark");

	Params::FortGlobalUIContext_GetWatermark Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.HideBang
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortBangType                           Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::HideBang(EFortBangType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "HideBang");

	Params::FortGlobalUIContext_HideBang Parms{};

	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.IsBluGloEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGlobalUIContext::IsBluGloEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "IsBluGloEnabled");

	Params::FortGlobalUIContext_IsBluGloEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.IsHUDVisible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGlobalUIContext::IsHUDVisible()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "IsHUDVisible");

	Params::FortGlobalUIContext_IsHUDVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.Logout
// (Final, Native, Public, BlueprintCallable)

void UFortGlobalUIContext::Logout()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "Logout");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.ProcessNotificationResult
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// EFortDialogResult                       InResult                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortDialogDescription&    NotificationDescription                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::ProcessNotificationResult(EFortDialogResult InResult, const struct FFortDialogDescription& NotificationDescription)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "ProcessNotificationResult");

	Params::FortGlobalUIContext_ProcessNotificationResult Parms{};

	Parms.InResult = InResult;
	Parms.NotificationDescription = std::move(NotificationDescription);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.QueryGameBackendVersion
// (Final, Native, Public, BlueprintCallable)

void UFortGlobalUIContext::QueryGameBackendVersion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "QueryGameBackendVersion");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.QuitGame
// (Final, Native, Public, BlueprintCallable)

void UFortGlobalUIContext::QuitGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "QuitGame");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.RegisterScriptedAction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class AFortScriptedAction>  ScriptedAction                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::RegisterScriptedAction(TSubclassOf<class AFortScriptedAction> ScriptedAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "RegisterScriptedAction");

	Params::FortGlobalUIContext_RegisterScriptedAction Parms{};

	Parms.ScriptedAction = ScriptedAction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.RegisterScriptedActions
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<TSubclassOf<class AFortScriptedAction>>&ScriptedActions                                        (Parm, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::RegisterScriptedActions(const TArray<TSubclassOf<class AFortScriptedAction>>& ScriptedActions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "RegisterScriptedActions");

	Params::FortGlobalUIContext_RegisterScriptedActions Parms{};

	Parms.ScriptedActions = std::move(ScriptedActions);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.RegisterToReceiveNotifications
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TDelegate<void()>                       InOnNotifcationAvailable                               (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::RegisterToReceiveNotifications(TDelegate<void()> InOnNotifcationAvailable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "RegisterToReceiveNotifications");

	Params::FortGlobalUIContext_RegisterToReceiveNotifications Parms{};

	Parms.InOnNotifcationAvailable = InOnNotifcationAvailable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.RemoveNotification
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortDialogDescription&    NotificationDescription                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::RemoveNotification(const struct FFortDialogDescription& NotificationDescription)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "RemoveNotification");

	Params::FortGlobalUIContext_RemoveNotification Parms{};

	Parms.NotificationDescription = std::move(NotificationDescription);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.SendExperienceRatingAnalytic
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    RatingType                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32&                            StarCount                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    GameSessionID                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Comment                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::SendExperienceRatingAnalytic(const class FString& RatingType, const int32& StarCount, const class FString& GameSessionID, const class FString& Comment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "SendExperienceRatingAnalytic");

	Params::FortGlobalUIContext_SendExperienceRatingAnalytic Parms{};

	Parms.RatingType = std::move(RatingType);
	Parms.StarCount = StarCount;
	Parms.GameSessionID = std::move(GameSessionID);
	Parms.Comment = std::move(Comment);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.SendLeaveZoneAnalytic
// (Final, Native, Public, BlueprintCallable)

void UFortGlobalUIContext::SendLeaveZoneAnalytic()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "SendLeaveZoneAnalytic");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.SendUINavigationAnalytic
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Destination                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUserInitiated                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::SendUINavigationAnalytic(const class FString& Destination, bool bUserInitiated)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "SendUINavigationAnalytic");

	Params::FortGlobalUIContext_SendUINavigationAnalytic Parms{};

	Parms.Destination = std::move(Destination);
	Parms.bUserInitiated = bUserInitiated;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.ShowBang
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortBangType                           Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::ShowBang(EFortBangType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "ShowBang");

	Params::FortGlobalUIContext_ShowBang Parms{};

	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.TakeScreenshot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TDelegate<void(int32 Width, int32 Height, const TArray<struct FColor>& Colors)>Callback                                               (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::TakeScreenshot(TDelegate<void(int32 Width, int32 Height, const TArray<struct FColor>& Colors)> Callback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "TakeScreenshot");

	Params::FortGlobalUIContext_TakeScreenshot Parms{};

	Parms.Callback = Callback;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.UnregisterScriptedAction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class AFortScriptedAction>  ScriptedAction                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::UnregisterScriptedAction(TSubclassOf<class AFortScriptedAction> ScriptedAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "UnregisterScriptedAction");

	Params::FortGlobalUIContext_UnregisterScriptedAction Parms{};

	Parms.ScriptedAction = ScriptedAction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.UnregisterToReceiveNotifications
// (Final, Native, Public, BlueprintCallable)

void UFortGlobalUIContext::UnregisterToReceiveNotifications()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "UnregisterToReceiveNotifications");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.ClearLastGameSummaryInfo
// (Final, Native, Public, BlueprintCallable, Const)

void UFortGlobalUIContext::ClearLastGameSummaryInfo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "ClearLastGameSummaryInfo");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGlobalUIContext.GetActiveKeybindSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortInputPreset                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortInputPreset UFortGlobalUIContext::GetActiveKeybindSet() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetActiveKeybindSet");

	Params::FortGlobalUIContext_GetActiveKeybindSet Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetFeatureState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortUIFeature                          Feature                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortUIFeatureState                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortUIFeatureState UFortGlobalUIContext::GetFeatureState(EFortUIFeature Feature) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetFeatureState");

	Params::FortGlobalUIContext_GetFeatureState Parms{};

	Parms.Feature = Feature;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetKeyForAction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Action                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FKey UFortGlobalUIContext::GetKeyForAction(class FName Action) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetKeyForAction");

	Params::FortGlobalUIContext_GetKeyForAction Parms{};

	Parms.Action = Action;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetKeyTextForAction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Action                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortGlobalUIContext::GetKeyTextForAction(class FName Action) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetKeyTextForAction");

	Params::FortGlobalUIContext_GetKeyTextForAction Parms{};

	Parms.Action = Action;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetLastGameSummaryInfo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGameSummaryInfo                 ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameSummaryInfo UFortGlobalUIContext::GetLastGameSummaryInfo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetLastGameSummaryInfo");

	Params::FortGlobalUIContext_GetLastGameSummaryInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetQuestManager
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortQuestManager*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortQuestManager* UFortGlobalUIContext::GetQuestManager() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetQuestManager");

	Params::FortGlobalUIContext_GetQuestManager Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.GetTeamPower
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  TeamPower                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  PersonalPower                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGlobalUIContext::GetTeamPower(int32* TeamPower, int32* PersonalPower) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "GetTeamPower");

	Params::FortGlobalUIContext_GetTeamPower Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (TeamPower != nullptr)
		*TeamPower = Parms.TeamPower;

	if (PersonalPower != nullptr)
		*PersonalPower = Parms.PersonalPower;
}


// Function FortniteUI.FortGlobalUIContext.IsInOutpostZone
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGlobalUIContext::IsInOutpostZone() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "IsInOutpostZone");

	Params::FortGlobalUIContext_IsInOutpostZone Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.IsInZone
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGlobalUIContext::IsInZone() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "IsInZone");

	Params::FortGlobalUIContext_IsInZone Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.IsUIVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGlobalUIContext::IsUIVisible() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "IsUIVisible");

	Params::FortGlobalUIContext_IsUIVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGlobalUIContext.ShouldCloseMenuOnEscape
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGlobalUIContext::ShouldCloseMenuOnEscape() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGlobalUIContext", "ShouldCloseMenuOnEscape");

	Params::FortGlobalUIContext_ShouldCloseMenuOnEscape Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortGridPickerTile.ForwardClicked
// (Final, Native, Protected, BlueprintCallable)

void UFortGridPickerTile::ForwardClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridPickerTile", "ForwardClicked");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridPickerTile.OnClicked
// (Event, Protected, BlueprintEvent)

void UFortGridPickerTile::OnClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridPickerTile", "OnClicked");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortGridPickerTile.OnMouseEnter
// (Event, Protected, BlueprintEvent)

void UFortGridPickerTile::OnMouseEnter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridPickerTile", "OnMouseEnter");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortGridPickerTile.OnMouseLeave
// (Event, Protected, BlueprintEvent)

void UFortGridPickerTile::OnMouseLeave()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridPickerTile", "OnMouseLeave");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortGridPickerTile.SetData
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UObject*                          InData                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGridPickerTile::SetData(class UObject* InData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridPickerTile", "SetData");

	Params::FortGridPickerTile_SetData Parms{};

	Parms.InData = InData;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortGridWidgetBase.SetClearWidgetType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UFortGridPickerTile>  InClearWidgetType                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGridWidgetBase::SetClearWidgetType(TSubclassOf<class UFortGridPickerTile> InClearWidgetType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridWidgetBase", "SetClearWidgetType");

	Params::FortGridWidgetBase_SetClearWidgetType Parms{};

	Parms.InClearWidgetType = InClearWidgetType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridWidgetBase.SetDataProvider
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UObject*>&           Data                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UFortGridWidgetBase::SetDataProvider(const TArray<class UObject*>& Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridWidgetBase", "SetDataProvider");

	Params::FortGridWidgetBase_SetDataProvider Parms{};

	Parms.Data = std::move(Data);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridWidgetBase.SetPeekOverflowTilePercentage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Percent                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGridWidgetBase::SetPeekOverflowTilePercentage(float Percent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridWidgetBase", "SetPeekOverflowTilePercentage");

	Params::FortGridWidgetBase_SetPeekOverflowTilePercentage Parms{};

	Parms.Percent = Percent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridWidgetBase.SetTileHeight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Height                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGridWidgetBase::SetTileHeight(float Height)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridWidgetBase", "SetTileHeight");

	Params::FortGridWidgetBase_SetTileHeight Parms{};

	Parms.Height = Height;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridWidgetBase.SetTilePadding
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FMargin&                   Padding                                                (Parm, NativeAccessSpecifierPublic)

void UFortGridWidgetBase::SetTilePadding(const struct FMargin& Padding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridWidgetBase", "SetTilePadding");

	Params::FortGridWidgetBase_SetTilePadding Parms{};

	Parms.Padding = std::move(Padding);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridWidgetBase.SetTilesAcross
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Across                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGridWidgetBase::SetTilesAcross(int32 Across)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridWidgetBase", "SetTilesAcross");

	Params::FortGridWidgetBase_SetTilesAcross Parms{};

	Parms.Across = Across;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridWidgetBase.SetTilesDown
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Down                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGridWidgetBase::SetTilesDown(int32 Down)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridWidgetBase", "SetTilesDown");

	Params::FortGridWidgetBase_SetTilesDown Parms{};

	Parms.Down = Down;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridWidgetBase.SetTileWidth
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Width                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGridWidgetBase::SetTileWidth(float Width)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridWidgetBase", "SetTileWidth");

	Params::FortGridWidgetBase_SetTileWidth Parms{};

	Parms.Width = Width;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridPickerButton.OnButtonClicked
// (Final, Native, Public, BlueprintCallable)

void UFortGridPickerButton::OnButtonClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridPickerButton", "OnButtonClicked");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortGridPickerButton.SetIsOpen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              ShouldBeOpen                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortGridPickerButton::SetIsOpen(const bool ShouldBeOpen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGridPickerButton", "SetIsOpen");

	Params::FortGridPickerButton_SetIsOpen Parms{};

	Parms.ShouldBeOpen = ShouldBeOpen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortHeroManagementContext.CanAffordAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitDepth                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::CanAffordAbility(int32 TraitIdx, int32 TraitDepth)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "CanAffordAbility");

	Params::FortHeroManagementContext_CanAffordAbility Parms{};

	Parms.TraitIdx = TraitIdx;
	Parms.TraitDepth = TraitDepth;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.CanAffordAbilityFromID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitDepth                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::CanAffordAbilityFromID(const class FString& HeroId, int32 TraitIdx, int32 TraitDepth)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "CanAffordAbilityFromID");

	Params::FortHeroManagementContext_CanAffordAbilityFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;
	Parms.TraitDepth = TraitDepth;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.CanAffordNextAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::CanAffordNextAbility(int32 TraitIdx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "CanAffordNextAbility");

	Params::FortHeroManagementContext_CanAffordNextAbility Parms{};

	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.CanAffordNextAbilityFromID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::CanAffordNextAbilityFromID(const class FString& HeroId, int32 TraitIdx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "CanAffordNextAbilityFromID");

	Params::FortHeroManagementContext_CanAffordNextAbilityFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetCurrentHeroID
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class FString*                          HeroId                                                 (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::GetCurrentHeroID(class FString* HeroId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetCurrentHeroID");

	Params::FortHeroManagementContext_GetCurrentHeroID Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HeroId != nullptr)
		*HeroId = std::move(Parms.HeroId);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetDisplayStats
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<struct FFortGameplayEffectModifierDescription>*Stats                                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortHeroManagementContext::GetDisplayStats(TArray<struct FFortGameplayEffectModifierDescription>* Stats)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetDisplayStats");

	Params::FortHeroManagementContext_GetDisplayStats Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Stats != nullptr)
		*Stats = std::move(Parms.Stats);
}


// Function FortniteUI.FortHeroManagementContext.GetEmptyHeroSlots
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FEmptyHeroSlot>           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FEmptyHeroSlot> UFortHeroManagementContext::GetEmptyHeroSlots()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetEmptyHeroSlots");

	Params::FortHeroManagementContext_GetEmptyHeroSlots Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetHeroData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FHeroUIData*                     HeroData                                               (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::GetHeroData(struct FHeroUIData* HeroData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetHeroData");

	Params::FortHeroManagementContext_GetHeroData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HeroData != nullptr)
		*HeroData = std::move(Parms.HeroData);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetHeroDataFromID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHeroUIData                      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FHeroUIData UFortHeroManagementContext::GetHeroDataFromID(const class FString& HeroId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetHeroDataFromID");

	Params::FortHeroManagementContext_GetHeroDataFromID Parms{};

	Parms.HeroId = std::move(HeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.PurchaseNextAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::PurchaseNextAbility(int32 TraitIdx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "PurchaseNextAbility");

	Params::FortHeroManagementContext_PurchaseNextAbility Parms{};

	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.PurchaseNextAbilityFromID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::PurchaseNextAbilityFromID(const class FString& HeroId, int32 TraitIdx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "PurchaseNextAbilityFromID");

	Params::FortHeroManagementContext_PurchaseNextAbilityFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.RedeemAllAbilities
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::RedeemAllAbilities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "RedeemAllAbilities");

	Params::FortHeroManagementContext_RedeemAllAbilities Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.RedeemAllAbilitiesFromID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortHeroManagementContext::RedeemAllAbilitiesFromID(const class FString& HeroId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "RedeemAllAbilitiesFromID");

	Params::FortHeroManagementContext_RedeemAllAbilitiesFromID Parms{};

	Parms.HeroId = std::move(HeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortHeroManagementContext.RedeemPrevAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::RedeemPrevAbility(int32 TraitIdx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "RedeemPrevAbility");

	Params::FortHeroManagementContext_RedeemPrevAbility Parms{};

	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.RedeemPrevAbilityFromID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::RedeemPrevAbilityFromID(const class FString& HeroId, int32 TraitIdx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "RedeemPrevAbilityFromID");

	Params::FortHeroManagementContext_RedeemPrevAbilityFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.RequestCreateHero
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UFortHeroType*              HeroType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Name_0                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortCustomGender                       Gender                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::RequestCreateHero(const class UFortHeroType* HeroType, const class FString& Name_0, EFortCustomGender Gender)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "RequestCreateHero");

	Params::FortHeroManagementContext_RequestCreateHero Parms{};

	Parms.HeroType = HeroType;
	Parms.Name_0 = std::move(Name_0);
	Parms.Gender = Gender;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.RequestDeleteHero
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::RequestDeleteHero(const class FString& HeroId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "RequestDeleteHero");

	Params::FortHeroManagementContext_RequestDeleteHero Parms{};

	Parms.HeroId = std::move(HeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.RequestSetTraitDepth
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Depth                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::RequestSetTraitDepth(int32 TraitIdx, int32 Depth)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "RequestSetTraitDepth");

	Params::FortHeroManagementContext_RequestSetTraitDepth Parms{};

	Parms.TraitIdx = TraitIdx;
	Parms.Depth = Depth;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.RequestSetTraitDepthFromID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Depth                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::RequestSetTraitDepthFromID(const class FString& HeroId, int32 TraitIdx, int32 Depth)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "RequestSetTraitDepthFromID");

	Params::FortHeroManagementContext_RequestSetTraitDepthFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;
	Parms.Depth = Depth;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.SetCurrentHero
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::SetCurrentHero(const class FString& HeroId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "SetCurrentHero");

	Params::FortHeroManagementContext_SetCurrentHero Parms{};

	Parms.HeroId = std::move(HeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.SetHeroName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    NewName                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::SetHeroName(const class FString& NewName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "SetHeroName");

	Params::FortHeroManagementContext_SetHeroName Parms{};

	Parms.NewName = std::move(NewName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.SetHeroNameFromID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    NewName                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::SetHeroNameFromID(const class FString& HeroId, const class FString& NewName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "SetHeroNameFromID");

	Params::FortHeroManagementContext_SetHeroNameFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.NewName = std::move(NewName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.SetShowingStatsScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsShowingStats                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortHeroManagementContext::SetShowingStatsScreen(bool bIsShowingStats)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "SetShowingStatsScreen");

	Params::FortHeroManagementContext_SetShowingStatsScreen Parms{};

	Parms.bIsShowingStats = bIsShowingStats;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortHeroManagementContext.CanModifyTraitDepth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::CanModifyTraitDepth(int32 TraitIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "CanModifyTraitDepth");

	Params::FortHeroManagementContext_CanModifyTraitDepth Parms{};

	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.CanModifyTraitDepthFromID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::CanModifyTraitDepthFromID(const class FString& HeroId, int32 TraitIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "CanModifyTraitDepthFromID");

	Params::FortHeroManagementContext_CanModifyTraitDepthFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.CanRedeemAllAbilities
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::CanRedeemAllAbilities() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "CanRedeemAllAbilities");

	Params::FortHeroManagementContext_CanRedeemAllAbilities Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.CheckHeroNameValidity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    Name_0                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ENameStatus                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ENameStatus UFortHeroManagementContext::CheckHeroNameValidity(const class FString& Name_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "CheckHeroNameValidity");

	Params::FortHeroManagementContext_CheckHeroNameValidity Parms{};

	Parms.Name_0 = std::move(Name_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GenerateRandomHeroName
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UDataTable*                 NameTable                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          Name_0                                                 (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortHeroManagementContext::GenerateRandomHeroName(const class UDataTable* NameTable, class FString* Name_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GenerateRandomHeroName");

	Params::FortHeroManagementContext_GenerateRandomHeroName Parms{};

	Parms.NameTable = NameTable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Name_0 != nullptr)
		*Name_0 = std::move(Parms.Name_0);
}


// Function FortniteUI.FortHeroManagementContext.GetAbilityCost
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitDepth                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortHeroManagementContext::GetAbilityCost(int32 TraitIdx, int32 TraitDepth) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetAbilityCost");

	Params::FortHeroManagementContext_GetAbilityCost Parms{};

	Parms.TraitIdx = TraitIdx;
	Parms.TraitDepth = TraitDepth;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetAbilityCostFromID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitDepth                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortHeroManagementContext::GetAbilityCostFromID(const class FString& HeroId, int32 TraitIdx, int32 TraitDepth) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetAbilityCostFromID");

	Params::FortHeroManagementContext_GetAbilityCostFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;
	Parms.TraitDepth = TraitDepth;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetAllHeroIDs
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UFortHeroManagementContext::GetAllHeroIDs() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetAllHeroIDs");

	Params::FortHeroManagementContext_GetAllHeroIDs Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetAttributeValue
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayAttribute&        Attribute                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortHeroManagementContext::GetAttributeValue(const struct FGameplayAttribute& Attribute) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetAttributeValue");

	Params::FortHeroManagementContext_GetAttributeValue Parms{};

	Parms.Attribute = std::move(Attribute);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetAttributeValueFromID
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayAttribute&        Attribute                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortHeroManagementContext::GetAttributeValueFromID(const class FString& HeroId, const struct FGameplayAttribute& Attribute) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetAttributeValueFromID");

	Params::FortHeroManagementContext_GetAttributeValueFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.Attribute = std::move(Attribute);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetAttributeValuesArray
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FGameplayAttribute>&Attributes                                             (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<float>*                          Values                                                 (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::GetAttributeValuesArray(const TArray<struct FGameplayAttribute>& Attributes, TArray<float>* Values) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetAttributeValuesArray");

	Params::FortHeroManagementContext_GetAttributeValuesArray Parms{};

	Parms.Attributes = std::move(Attributes);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Values != nullptr)
		*Values = std::move(Parms.Values);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetAttributeValuesArrayFromID
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FGameplayAttribute>&Attributes                                             (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<float>*                          Values                                                 (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::GetAttributeValuesArrayFromID(const class FString& HeroId, const TArray<struct FGameplayAttribute>& Attributes, TArray<float>* Values) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetAttributeValuesArrayFromID");

	Params::FortHeroManagementContext_GetAttributeValuesArrayFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.Attributes = std::move(Attributes);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Values != nullptr)
		*Values = std::move(Parms.Values);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetCoreAbilities
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortAbilityKit*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UFortAbilityKit*> UFortHeroManagementContext::GetCoreAbilities() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetCoreAbilities");

	Params::FortHeroManagementContext_GetCoreAbilities Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetCoreAbilitiesFromID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UFortAbilityKit*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UFortAbilityKit*> UFortHeroManagementContext::GetCoreAbilitiesFromID(const class FString& HeroId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetCoreAbilitiesFromID");

	Params::FortHeroManagementContext_GetCoreAbilitiesFromID Parms{};

	Parms.HeroId = std::move(HeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetMaxNameLength
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortHeroManagementContext::GetMaxNameLength() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetMaxNameLength");

	Params::FortHeroManagementContext_GetMaxNameLength Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetNextAbilityCost
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortHeroManagementContext::GetNextAbilityCost(int32 TraitIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetNextAbilityCost");

	Params::FortHeroManagementContext_GetNextAbilityCost Parms{};

	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetNextAbilityCostFromID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortHeroManagementContext::GetNextAbilityCostFromID(const class FString& HeroId, int32 TraitIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetNextAbilityCostFromID");

	Params::FortHeroManagementContext_GetNextAbilityCostFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetNumHeroTraits
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortHeroManagementContext::GetNumHeroTraits() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetNumHeroTraits");

	Params::FortHeroManagementContext_GetNumHeroTraits Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetNumUnspentAbilityPoints
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  NumAbilityPoints                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::GetNumUnspentAbilityPoints(int32* NumAbilityPoints) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetNumUnspentAbilityPoints");

	Params::FortHeroManagementContext_GetNumUnspentAbilityPoints Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (NumAbilityPoints != nullptr)
		*NumAbilityPoints = Parms.NumAbilityPoints;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetNumUnspentAbilityPointsFromID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortHeroManagementContext::GetNumUnspentAbilityPointsFromID(const class FString& HeroId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetNumUnspentAbilityPointsFromID");

	Params::FortHeroManagementContext_GetNumUnspentAbilityPointsFromID Parms{};

	Parms.HeroId = std::move(HeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetTrait
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortTrait*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortTrait* UFortHeroManagementContext::GetTrait(int32 TraitIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetTrait");

	Params::FortHeroManagementContext_GetTrait Parms{};

	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetTraitDepth
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  Depth                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::GetTraitDepth(int32 TraitIdx, int32* Depth) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetTraitDepth");

	Params::FortHeroManagementContext_GetTraitDepth Parms{};

	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Depth != nullptr)
		*Depth = Parms.Depth;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetTraitDepthFromID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortHeroManagementContext::GetTraitDepthFromID(const class FString& HeroId, int32 TraitIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetTraitDepthFromID");

	Params::FortHeroManagementContext_GetTraitDepthFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.GetTraitFromID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TraitIdx                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortTrait*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortTrait* UFortHeroManagementContext::GetTraitFromID(const class FString& HeroId, int32 TraitIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "GetTraitFromID");

	Params::FortHeroManagementContext_GetTraitFromID Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.TraitIdx = TraitIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.IsCreateHeroEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::IsCreateHeroEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "IsCreateHeroEnabled");

	Params::FortHeroManagementContext_IsCreateHeroEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.IsDeleteHeroEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::IsDeleteHeroEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "IsDeleteHeroEnabled");

	Params::FortHeroManagementContext_IsDeleteHeroEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.IsShowingStatsScreen
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::IsShowingStatsScreen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "IsShowingStatsScreen");

	Params::FortHeroManagementContext_IsShowingStatsScreen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.IsSkillTreeUnlocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::IsSkillTreeUnlocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "IsSkillTreeUnlocked");

	Params::FortHeroManagementContext_IsSkillTreeUnlocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.IsSkillTreeUnlockedFromID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHeroManagementContext::IsSkillTreeUnlockedFromID(const class FString& HeroId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "IsSkillTreeUnlockedFromID");

	Params::FortHeroManagementContext_IsSkillTreeUnlockedFromID Parms{};

	Parms.HeroId = std::move(HeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHeroManagementContext.NumHeroSlots
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortHeroManagementContext::NumHeroSlots() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHeroManagementContext", "NumHeroSlots");

	Params::FortHeroManagementContext_NumHeroSlots Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.EnterCameraMode
// (Final, Native, Public, BlueprintCallable)

void UFortHUDContext::EnterCameraMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "EnterCameraMode");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortHUDContext.EnterCursorMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ActionName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUserWidget*                      CursorModeWidget                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortHUDContext::EnterCursorMode(class FName ActionName, class UUserWidget* CursorModeWidget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "EnterCursorMode");

	Params::FortHUDContext_EnterCursorMode Parms{};

	Parms.ActionName = ActionName;
	Parms.CursorModeWidget = CursorModeWidget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortHUDContext.ForwardOnAbilityDecisionWindowStackUpdated
// (Final, Native, Private)

void UFortHUDContext::ForwardOnAbilityDecisionWindowStackUpdated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "ForwardOnAbilityDecisionWindowStackUpdated");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortHUDContext.ForwardOnWeaponEquipped
// (Final, Native, Private)
// Parameters:
// class AFortWeapon*                      NewWeapon                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortWeapon*                      PrevWeapon                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortHUDContext::ForwardOnWeaponEquipped(class AFortWeapon* NewWeapon, class AFortWeapon* PrevWeapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "ForwardOnWeaponEquipped");

	Params::FortHUDContext_ForwardOnWeaponEquipped Parms{};

	Parms.NewWeapon = NewWeapon;
	Parms.PrevWeapon = PrevWeapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortHUDContext.GetKillerVisualInfoFromDeathReport
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortPlayerDeathReport&    DeathReport                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FFortKillerVisualInfo            ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortKillerVisualInfo UFortHUDContext::GetKillerVisualInfoFromDeathReport(const struct FFortPlayerDeathReport& DeathReport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "GetKillerVisualInfoFromDeathReport");

	Params::FortHUDContext_GetKillerVisualInfoFromDeathReport Parms{};

	Parms.DeathReport = std::move(DeathReport);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.HandleLocalPawnDied
// (Final, Native, Private, HasOutParams)
// Parameters:
// const struct FFortPlayerDeathReport&    DeathReport                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortHUDContext::HandleLocalPawnDied(const struct FFortPlayerDeathReport& DeathReport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "HandleLocalPawnDied");

	Params::FortHUDContext_HandleLocalPawnDied Parms{};

	Parms.DeathReport = std::move(DeathReport);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortHUDContext.SetIndicatorsAllowed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIndicatorsAllowed                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortHUDContext::SetIndicatorsAllowed(bool bIndicatorsAllowed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "SetIndicatorsAllowed");

	Params::FortHUDContext_SetIndicatorsAllowed Parms{};

	Parms.bIndicatorsAllowed = bIndicatorsAllowed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortHUDContext.AreIndicatorsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHUDContext::AreIndicatorsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "AreIndicatorsEnabled");

	Params::FortHUDContext_AreIndicatorsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.GetCurrentHero
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortHero*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortHero* UFortHUDContext::GetCurrentHero() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "GetCurrentHero");

	Params::FortHUDContext_GetCurrentHero Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.GetFocusedBuildingInfo
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFortFocusedBuildingInfo*        OutBuildingInfo                                        (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHUDContext::GetFocusedBuildingInfo(struct FFortFocusedBuildingInfo* OutBuildingInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "GetFocusedBuildingInfo");

	Params::FortHUDContext_GetFocusedBuildingInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutBuildingInfo != nullptr)
		*OutBuildingInfo = std::move(Parms.OutBuildingInfo);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.GetGameStateZone
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortGameStateZone*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortGameStateZone* UFortHUDContext::GetGameStateZone() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "GetGameStateZone");

	Params::FortHUDContext_GetGameStateZone Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.GetPlayerAbilitySystemComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortAbilitySystemComponent*      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilitySystemComponent* UFortHUDContext::GetPlayerAbilitySystemComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "GetPlayerAbilitySystemComponent");

	Params::FortHUDContext_GetPlayerAbilitySystemComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.GetPlayerStateZone
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerStateZone*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlayerStateZone* UFortHUDContext::GetPlayerStateZone() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "GetPlayerStateZone");

	Params::FortHUDContext_GetPlayerStateZone Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.GetScoreDisplayFactor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortHUDContext::GetScoreDisplayFactor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "GetScoreDisplayFactor");

	Params::FortHUDContext_GetScoreDisplayFactor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.GetTeamCornerstone
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortTeam                               Team                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPvPBaseCornerstone*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPvPBaseCornerstone* UFortHUDContext::GetTeamCornerstone(EFortTeam Team) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "GetTeamCornerstone");

	Params::FortHUDContext_GetTeamCornerstone Parms{};

	Parms.Team = Team;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortHUDContext.IsInCursorMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortHUDContext::IsInCursorMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHUDContext", "IsInCursorMode");

	Params::FortHUDContext_IsInCursorMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.ActivateItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortItem*                        Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::ActivateItem(class UFortItem* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "ActivateItem");

	Params::FortInventoryContext_ActivateItem Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.CraftSchematic
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UFortSchematicItem*               SchematicItem                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortCraftFailCause*                    FailCause                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::CraftSchematic(class UFortSchematicItem* SchematicItem, EFortCraftFailCause* FailCause)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "CraftSchematic");

	Params::FortInventoryContext_CraftSchematic Parms{};

	Parms.SchematicItem = SchematicItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (FailCause != nullptr)
		*FailCause = Parms.FailCause;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.DisassembleItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortWorldItem*                   Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::DisassembleItem(class UFortWorldItem* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "DisassembleItem");

	Params::FortInventoryContext_DisassembleItem Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.DropItemOnPlayerOrWorld
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UFortWorldItem*             ItemBeingDropped                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerState*                 InDestinationPlayer                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWidget*                          OwnerWidget                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPointerEvent&             PointerEvent                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGeometry&                 InGeometry                                             (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortInventoryContext::DropItemOnPlayerOrWorld(const class UFortWorldItem* ItemBeingDropped, class AFortPlayerState* InDestinationPlayer, class UWidget* OwnerWidget, const struct FPointerEvent& PointerEvent, const struct FGeometry& InGeometry)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "DropItemOnPlayerOrWorld");

	Params::FortInventoryContext_DropItemOnPlayerOrWorld Parms{};

	Parms.ItemBeingDropped = ItemBeingDropped;
	Parms.InDestinationPlayer = InDestinationPlayer;
	Parms.OwnerWidget = OwnerWidget;
	Parms.PointerEvent = std::move(PointerEvent);
	Parms.InGeometry = std::move(InGeometry);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortInventoryContext.DropItemOnQuickBar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortItem*                        Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortQuickBars                          TargetQuickbar                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TargetSlot                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::DropItemOnQuickBar(class UFortItem* Item, EFortQuickBars TargetQuickbar, int32 TargetSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "DropItemOnQuickBar");

	Params::FortInventoryContext_DropItemOnQuickBar Parms{};

	Parms.Item = Item;
	Parms.TargetQuickbar = TargetQuickbar;
	Parms.TargetSlot = TargetSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.LockAllSchematics
// (Final, Native, Public, BlueprintCallable)

void UFortInventoryContext::LockAllSchematics()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "LockAllSchematics");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortInventoryContext.RemoveItemFromQuickBar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortItem*                        Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::RemoveItemFromQuickBar(class UFortItem* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "RemoveItemFromQuickBar");

	Params::FortInventoryContext_RemoveItemFromQuickBar Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.SetSchematicPinned
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortSchematicItem*               Schematic                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::SetSchematicPinned(class UFortSchematicItem* Schematic, bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "SetSchematicPinned");

	Params::FortInventoryContext_SetSchematicPinned Parms{};

	Parms.Schematic = Schematic;
	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.UnlockAllSchematics
// (Final, Native, Public, BlueprintCallable)

void UFortInventoryContext::UnlockAllSchematics()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "UnlockAllSchematics");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortInventoryContext.UnlockSchematic
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortSchematicItemDefinition*     SchematicDefinition                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortInventoryContext::UnlockSchematic(class UFortSchematicItemDefinition* SchematicDefinition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "UnlockSchematic");

	Params::FortInventoryContext_UnlockSchematic Parms{};

	Parms.SchematicDefinition = SchematicDefinition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortInventoryContext.CanCraftSchematic
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortSchematicItem*               SchematicItem                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortCraftFailCause*                    FailCause                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::CanCraftSchematic(class UFortSchematicItem* SchematicItem, EFortCraftFailCause* FailCause) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "CanCraftSchematic");

	Params::FortInventoryContext_CanCraftSchematic Parms{};

	Parms.SchematicItem = SchematicItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (FailCause != nullptr)
		*FailCause = Parms.FailCause;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.CanDisassembleItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortWorldItem*                   Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::CanDisassembleItem(class UFortWorldItem* Item) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "CanDisassembleItem");

	Params::FortInventoryContext_CanDisassembleItem Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.CanPinSchematic
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortSchematicItem*               Schematic                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::CanPinSchematic(class UFortSchematicItem* Schematic) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "CanPinSchematic");

	Params::FortInventoryContext_CanPinSchematic Parms{};

	Parms.Schematic = Schematic;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.DoesItemMatchFilter
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortItem*                        Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortItemListFilter&       FilterSettings                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::DoesItemMatchFilter(class UFortItem* Item, const struct FFortItemListFilter& FilterSettings) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "DoesItemMatchFilter");

	Params::FortInventoryContext_DoesItemMatchFilter Parms{};

	Parms.Item = Item;
	Parms.FilterSettings = std::move(FilterSettings);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetBackpackItemCounts
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  ItemsCount                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  MaxItemsCount                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OverflowItemsCount                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortInventoryContext::GetBackpackItemCounts(int32* ItemsCount, int32* MaxItemsCount, int32* OverflowItemsCount) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetBackpackItemCounts");

	Params::FortInventoryContext_GetBackpackItemCounts Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ItemsCount != nullptr)
		*ItemsCount = Parms.ItemsCount;

	if (MaxItemsCount != nullptr)
		*MaxItemsCount = Parms.MaxItemsCount;

	if (OverflowItemsCount != nullptr)
		*OverflowItemsCount = Parms.OverflowItemsCount;
}


// Function FortniteUI.FortInventoryContext.GetCurrentAmmoIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UFortInventoryContext::GetCurrentAmmoIcon() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetCurrentAmmoIcon");

	Params::FortInventoryContext_GetCurrentAmmoIcon Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetCurrentAmmoItemDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortWorldItemDefinition*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortWorldItemDefinition* UFortInventoryContext::GetCurrentAmmoItemDefinition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetCurrentAmmoItemDefinition");

	Params::FortInventoryContext_GetCurrentAmmoItemDefinition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetCurrentResourceCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortInventoryContext::GetCurrentResourceCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetCurrentResourceCount");

	Params::FortInventoryContext_GetCurrentResourceCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetCurrentResourceIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UFortInventoryContext::GetCurrentResourceIcon() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetCurrentResourceIcon");

	Params::FortInventoryContext_GetCurrentResourceIcon Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetCurrentResourceItemDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortResourceItemDefinition*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortResourceItemDefinition* UFortInventoryContext::GetCurrentResourceItemDefinition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetCurrentResourceItemDefinition");

	Params::FortInventoryContext_GetCurrentResourceItemDefinition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetEquippedWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortWeapon*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortWeapon* UFortInventoryContext::GetEquippedWeapon() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetEquippedWeapon");

	Params::FortInventoryContext_GetEquippedWeapon Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetNumInInventory
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortWorldItemDefinition*         ItemDefinition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludeReserved                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortInventoryContext::GetNumInInventory(class UFortWorldItemDefinition* ItemDefinition, bool bIncludeReserved) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetNumInInventory");

	Params::FortInventoryContext_GetNumInInventory Parms{};

	Parms.ItemDefinition = ItemDefinition;
	Parms.bIncludeReserved = bIncludeReserved;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetPinnedSchematicList
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortSchematicItem*>*      PinnedItems                                            (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortInventoryContext::GetPinnedSchematicList(TArray<class UFortSchematicItem*>* PinnedItems) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetPinnedSchematicList");

	Params::FortInventoryContext_GetPinnedSchematicList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (PinnedItems != nullptr)
		*PinnedItems = std::move(Parms.PinnedItems);
}


// Function FortniteUI.FortInventoryContext.GetQuickbarFocus
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortQuickBars*                         OutQuickBar                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutSlot                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortInventoryContext::GetQuickbarFocus(EFortQuickBars* OutQuickBar, int32* OutSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetQuickbarFocus");

	Params::FortInventoryContext_GetQuickbarFocus Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutQuickBar != nullptr)
		*OutQuickBar = Parms.OutQuickBar;

	if (OutSlot != nullptr)
		*OutSlot = Parms.OutSlot;
}


// Function FortniteUI.FortInventoryContext.GetQuickBarSlottedItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortQuickBars                          InQuickBar                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortItem*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortItem* UFortInventoryContext::GetQuickBarSlottedItem(EFortQuickBars InQuickBar, int32 Slot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetQuickBarSlottedItem");

	Params::FortInventoryContext_GetQuickBarSlottedItem Parms{};

	Parms.InQuickBar = InQuickBar;
	Parms.Slot = Slot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetResourceCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortResourceType                       ResourceType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortInventoryContext::GetResourceCount(EFortResourceType ResourceType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetResourceCount");

	Params::FortInventoryContext_GetResourceCount Parms{};

	Parms.ResourceType = ResourceType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetResourceIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortResourceType                       ResourceType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UFortInventoryContext::GetResourceIcon(EFortResourceType ResourceType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetResourceIcon");

	Params::FortInventoryContext_GetResourceIcon Parms{};

	Parms.ResourceType = ResourceType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetResourceItemDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortResourceType                       ResourceType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortResourceItemDefinition*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortResourceItemDefinition* UFortInventoryContext::GetResourceItemDefinition(EFortResourceType ResourceType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetResourceItemDefinition");

	Params::FortInventoryContext_GetResourceItemDefinition Parms{};

	Parms.ResourceType = ResourceType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.GetSchematicItemList
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortSchematicItem*>*      Items                                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const struct FFortItemListFilter&       FilterSettings                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortInventoryContext::GetSchematicItemList(TArray<class UFortSchematicItem*>* Items, const struct FFortItemListFilter& FilterSettings) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetSchematicItemList");

	Params::FortInventoryContext_GetSchematicItemList Parms{};

	Parms.FilterSettings = std::move(FilterSettings);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Items != nullptr)
		*Items = std::move(Parms.Items);
}


// Function FortniteUI.FortInventoryContext.GetWorldItemList
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortWorldItem*>*          Items                                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const struct FFortItemListFilter&       FilterSettings                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortInventoryContext::GetWorldItemList(TArray<class UFortWorldItem*>* Items, const struct FFortItemListFilter& FilterSettings) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "GetWorldItemList");

	Params::FortInventoryContext_GetWorldItemList Parms{};

	Parms.FilterSettings = std::move(FilterSettings);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Items != nullptr)
		*Items = std::move(Parms.Items);
}


// Function FortniteUI.FortInventoryContext.IsSchematicPinned
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortSchematicItem*               Schematic                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::IsSchematicPinned(class UFortSchematicItem* Schematic) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "IsSchematicPinned");

	Params::FortInventoryContext_IsSchematicPinned Parms{};

	Parms.Schematic = Schematic;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortInventoryContext.WillQuickBarAcceptItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortItem*                        Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortQuickBars                          InQuickBar                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortInventoryContext::WillQuickBarAcceptItem(class UFortItem* Item, EFortQuickBars InQuickBar, int32 Slot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventoryContext", "WillQuickBarAcceptItem");

	Params::FortInventoryContext_WillQuickBarAcceptItem Parms{};

	Parms.Item = Item;
	Parms.InQuickBar = InQuickBar;
	Parms.Slot = Slot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortLegacySlateBridgeWidget.SetOnCloseHandler
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void()>&                OnCloseHandler                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UFortLegacySlateBridgeWidget::SetOnCloseHandler(const TDelegate<void()>& OnCloseHandler)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLegacySlateBridgeWidget", "SetOnCloseHandler");

	Params::FortLegacySlateBridgeWidget_SetOnCloseHandler Parms{};

	Parms.OnCloseHandler = OnCloseHandler;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLegacySlateBridgeWidget.UpdateSlateWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortLegacySlateWidget                  SlateWidgetType                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortLegacySlateBridgeWidget::UpdateSlateWidget(EFortLegacySlateWidget SlateWidgetType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLegacySlateBridgeWidget", "UpdateSlateWidget");

	Params::FortLegacySlateBridgeWidget_UpdateSlateWidget Parms{};

	Parms.SlateWidgetType = SlateWidgetType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortListView.AddItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          NewItem                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortListView::AddItem(class UObject* NewItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListView", "AddItem");

	Params::FortListView_AddItem Parms{};

	Parms.NewItem = NewItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortListView.Clear
// (Final, Native, Public, BlueprintCallable)

void UFortListView::Clear()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListView", "Clear");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortListView.ClearSelection
// (Final, Native, Public, BlueprintCallable)

void UFortListView::ClearSelection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListView", "ClearSelection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortListView.RemoveItemAt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortListView::RemoveItemAt(int32 INDEX)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListView", "RemoveItemAt");

	Params::FortListView_RemoveItemAt Parms{};

	Parms.INDEX = INDEX;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortListView.SetDataProvider
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UObject*>&           NewData                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UFortListView::SetDataProvider(const TArray<class UObject*>& NewData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListView", "SetDataProvider");

	Params::FortListView_SetDataProvider Parms{};

	Parms.NewData = std::move(NewData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortListView.SetIndexSelected
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortListView::SetIndexSelected(int32 INDEX)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListView", "SetIndexSelected");

	Params::FortListView_SetIndexSelected Parms{};

	Parms.INDEX = INDEX;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortListView.SetItemSelected
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortListView::SetItemSelected(class UObject* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListView", "SetItemSelected");

	Params::FortListView_SetItemSelected Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortListView.GetIndexForItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortListView::GetIndexForItem(class UObject* Item) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListView", "GetIndexForItem");

	Params::FortListView_GetIndexForItem Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortListView.GetItemAt
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UFortListView::GetItemAt(int32 INDEX) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListView", "GetItemAt");

	Params::FortListView_GetItemAt Parms{};

	Parms.INDEX = INDEX;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortSocialListView.SetList
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UFortSocialItem*>&   InList                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UFortSocialListView::SetList(const TArray<class UFortSocialItem*>& InList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSocialListView", "SetList");

	Params::FortSocialListView_SetList Parms{};

	Parms.InList = std::move(InList);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortStoreContext.CardAddedToSummaryComplete
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::CardAddedToSummaryComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "CardAddedToSummaryComplete");

	Params::FortStoreContext_CardAddedToSummaryComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.CardBackRevealComplete
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::CardBackRevealComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "CardBackRevealComplete");

	Params::FortStoreContext_CardBackRevealComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.CardEntryComplete
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::CardEntryComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "CardEntryComplete");

	Params::FortStoreContext_CardEntryComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.CardExitComplete
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::CardExitComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "CardExitComplete");

	Params::FortStoreContext_CardExitComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.CardFlipComplete
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::CardFlipComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "CardFlipComplete");

	Params::FortStoreContext_CardFlipComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.CardFrontRevealComplete
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::CardFrontRevealComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "CardFrontRevealComplete");

	Params::FortStoreContext_CardFrontRevealComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.CardPackDestroyComplete
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::CardPackDestroyComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "CardPackDestroyComplete");

	Params::FortStoreContext_CardPackDestroyComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.CardPackOpeningComplete
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::CardPackOpeningComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "CardPackOpeningComplete");

	Params::FortStoreContext_CardPackOpeningComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.DismissError
// (Final, Native, Public, BlueprintCallable)

void UFortStoreContext::DismissError()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "DismissError");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortStoreContext.EnterCardPackStore
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::EnterCardPackStore()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "EnterCardPackStore");

	Params::FortStoreContext_EnterCardPackStore Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.EnterCurrencyStore
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttemptedPurchaseCardPackId                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::EnterCurrencyStore(const class FString& AttemptedPurchaseCardPackId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "EnterCurrencyStore");

	Params::FortStoreContext_EnterCurrencyStore Parms{};

	Parms.AttemptedPurchaseCardPackId = std::move(AttemptedPurchaseCardPackId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.ErrorOccurred
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ErrorAnalytics                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::ErrorOccurred(const class FString& ErrorAnalytics)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "ErrorOccurred");

	Params::FortStoreContext_ErrorOccurred Parms{};

	Parms.ErrorAnalytics = std::move(ErrorAnalytics);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.ExitCardPackStore
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::ExitCardPackStore()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "ExitCardPackStore");

	Params::FortStoreContext_ExitCardPackStore Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.ExitCurrencyStore
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::ExitCurrencyStore()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "ExitCurrencyStore");

	Params::FortStoreContext_ExitCurrencyStore Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.ExitSummary
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::ExitSummary()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "ExitSummary");

	Params::FortStoreContext_ExitSummary Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.ExitWebPayment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::ExitWebPayment()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "ExitWebPayment");

	Params::FortStoreContext_ExitWebPayment Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.FreshenCache
// (Final, Native, Public, BlueprintCallable)

void UFortStoreContext::FreshenCache()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "FreshenCache");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortStoreContext.GetAccountItems
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UFortAccountItemDefinition*>&AccountItemDefinitions                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UFortAccountItem*>*        AccountItems                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortStoreContext::GetAccountItems(const TArray<class UFortAccountItemDefinition*>& AccountItemDefinitions, TArray<class UFortAccountItem*>* AccountItems)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "GetAccountItems");

	Params::FortStoreContext_GetAccountItems Parms{};

	Parms.AccountItemDefinitions = std::move(AccountItemDefinitions);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AccountItems != nullptr)
		*AccountItems = std::move(Parms.AccountItems);
}


// Function FortniteUI.FortStoreContext.GetRarityColor
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// EFortRarity                             Rarity                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FLinearColor UFortStoreContext::GetRarityColor(EFortRarity Rarity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "GetRarityColor");

	Params::FortStoreContext_GetRarityColor Parms{};

	Parms.Rarity = Rarity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.GetTimeUntilDailyLimitReset
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FTimespan                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

struct FTimespan UFortStoreContext::GetTimeUntilDailyLimitReset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "GetTimeUntilDailyLimitReset");

	Params::FortStoreContext_GetTimeUntilDailyLimitReset Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.GetTimeUntilMarketplaceRefresh
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FTimespan                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

struct FTimespan UFortStoreContext::GetTimeUntilMarketplaceRefresh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "GetTimeUntilMarketplaceRefresh");

	Params::FortStoreContext_GetTimeUntilMarketplaceRefresh Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.MakePurchase
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FCardPackOffer&            Offer                                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   Quantity                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECardPackPurchaseError                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECardPackPurchaseError UFortStoreContext::MakePurchase(const struct FCardPackOffer& Offer, int32 Quantity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "MakePurchase");

	Params::FortStoreContext_MakePurchase Parms{};

	Parms.Offer = std::move(Offer);
	Parms.Quantity = Quantity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.OpenWebPayment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttemptedMTXOfferId                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::OpenWebPayment(const class FString& AttemptedMTXOfferId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "OpenWebPayment");

	Params::FortStoreContext_OpenWebPayment Parms{};

	Parms.AttemptedMTXOfferId = std::move(AttemptedMTXOfferId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.FireInteractionAnalyticsEvent
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// const class FString&                    Interaction                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Details                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortStoreContext::FireInteractionAnalyticsEvent(const class FString& Interaction, const class FString& Details) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "FireInteractionAnalyticsEvent");

	Params::FortStoreContext_FireInteractionAnalyticsEvent Parms{};

	Parms.Interaction = std::move(Interaction);
	Parms.Details = std::move(Details);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortStoreContext.GetCard
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   CardIdx                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FCard*                           ResultOut                                              (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::GetCard(int32 CardIdx, struct FCard* ResultOut) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "GetCard");

	Params::FortStoreContext_GetCard Parms{};

	Parms.CardIdx = CardIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ResultOut != nullptr)
		*ResultOut = std::move(Parms.ResultOut);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.GetNumUnopenedCardPacksRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UFortCardPackItemDefinition*PackType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortStoreContext::GetNumUnopenedCardPacksRemaining(const class UFortCardPackItemDefinition* PackType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "GetNumUnopenedCardPacksRemaining");

	Params::FortStoreContext_GetNumUnopenedCardPacksRemaining Parms{};

	Parms.PackType = PackType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.GetPreviousState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortStoreState                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortStoreState UFortStoreContext::GetPreviousState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "GetPreviousState");

	Params::FortStoreContext_GetPreviousState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.GetStoreState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortStoreState                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortStoreState UFortStoreContext::GetStoreState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "GetStoreState");

	Params::FortStoreContext_GetStoreState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.IsCatalogAvailable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::IsCatalogAvailable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "IsCatalogAvailable");

	Params::FortStoreContext_IsCatalogAvailable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortStoreContext.IsNewStoreEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortStoreContext::IsNewStoreEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortStoreContext", "IsNewStoreEnabled");

	Params::FortStoreContext_IsNewStoreEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortUIMessageManager.AddMessageItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortUIMessageItemWidget*         MessageItem                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIMessageManager::AddMessageItem(class UFortUIMessageItemWidget* MessageItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIMessageManager", "AddMessageItem");

	Params::FortUIMessageManager_AddMessageItem Parms{};

	Parms.MessageItem = MessageItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIMessageManager.GetNextMessageInQueue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortUIMessageItemWidget*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortUIMessageItemWidget* UFortUIMessageManager::GetNextMessageInQueue()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIMessageManager", "GetNextMessageInQueue");

	Params::FortUIMessageManager_GetNextMessageInQueue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortUIMessageManager.HandleMessageDisplayed
// (Final, Native, Private)
// Parameters:
// class UFortUIMessageItemWidget*         MessageItem                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIMessageManager::HandleMessageDisplayed(class UFortUIMessageItemWidget* MessageItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIMessageManager", "HandleMessageDisplayed");

	Params::FortUIMessageManager_HandleMessageDisplayed Parms{};

	Parms.MessageItem = MessageItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIMessageManager.HandleMessageRemoved
// (Final, Native, Private)
// Parameters:
// class UFortUIMessageItemWidget*         MessageItem                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIMessageManager::HandleMessageRemoved(class UFortUIMessageItemWidget* MessageItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIMessageManager", "HandleMessageRemoved");

	Params::FortUIMessageManager_HandleMessageRemoved Parms{};

	Parms.MessageItem = MessageItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIMessageManager.GetNumDisplayedItems
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortUIMessageManager::GetNumDisplayedItems() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIMessageManager", "GetNumDisplayedItems");

	Params::FortUIMessageManager_GetNumDisplayedItems Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortUIStateTrigger.EvalBP
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortUIStateTrigger::EvalBP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIStateTrigger", "EvalBP");

	Params::FortUIStateTrigger_EvalBP Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortUIStateTrigger.IsLoggedIn
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortUIStateTrigger::IsLoggedIn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIStateTrigger", "IsLoggedIn");

	Params::FortUIStateTrigger_IsLoggedIn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortActionHandlerPanel.ActivateActionHandler
// (Final, Native, Protected, BlueprintCallable)

void UFortActionHandlerPanel::ActivateActionHandler()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActionHandlerPanel", "ActivateActionHandler");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortActionHandlerPanel.DeactivateActionHandler
// (Final, Native, Protected, BlueprintCallable)

void UFortActionHandlerPanel::DeactivateActionHandler()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActionHandlerPanel", "DeactivateActionHandler");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortActionHandlerPanel.OnHandleAction
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// struct FEventReply*                     Result                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// bool*                                   bPassThrough                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortActionHandlerPanel::OnHandleAction(struct FEventReply* Result, bool* bPassThrough)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActionHandlerPanel", "OnHandleAction");

	Params::FortActionHandlerPanel_OnHandleAction Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Result != nullptr)
		*Result = std::move(Parms.Result);

	if (bPassThrough != nullptr)
		*bPassThrough = Parms.bPassThrough;
}


// Function FortniteUI.FortActionHandlerPanel.RemoveOnPanelActivated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          BoundObject                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortActionHandlerPanel::RemoveOnPanelActivated(class UObject* BoundObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActionHandlerPanel", "RemoveOnPanelActivated");

	Params::FortActionHandlerPanel_RemoveOnPanelActivated Parms{};

	Parms.BoundObject = BoundObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortActionHandlerPanel.RemoveOnPanelDeactivated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          BoundObject                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortActionHandlerPanel::RemoveOnPanelDeactivated(class UObject* BoundObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActionHandlerPanel", "RemoveOnPanelDeactivated");

	Params::FortActionHandlerPanel_RemoveOnPanelDeactivated Parms{};

	Parms.BoundObject = BoundObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortActionHandlerPanel.SetOnPanelActivated
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void()>&                OnActivatedHandler                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UFortActionHandlerPanel::SetOnPanelActivated(const TDelegate<void()>& OnActivatedHandler)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActionHandlerPanel", "SetOnPanelActivated");

	Params::FortActionHandlerPanel_SetOnPanelActivated Parms{};

	Parms.OnActivatedHandler = OnActivatedHandler;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortActionHandlerPanel.SetOnPanelDeactivated
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void()>&                OnDeactivatedHandler                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UFortActionHandlerPanel::SetOnPanelDeactivated(const TDelegate<void()>& OnDeactivatedHandler)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActionHandlerPanel", "SetOnPanelDeactivated");

	Params::FortActionHandlerPanel_SetOnPanelDeactivated Parms{};

	Parms.OnDeactivatedHandler = OnDeactivatedHandler;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortConfirmationWindow.KillConfirmation
// (Final, Native, Public, BlueprintCallable)

void UFortConfirmationWindow::KillConfirmation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConfirmationWindow", "KillConfirmation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortConfirmationWindow.OnKill
// (Event, Protected, BlueprintEvent)

void UFortConfirmationWindow::OnKill()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConfirmationWindow", "OnKill");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortConfirmationWindow.OnShow
// (Event, Protected, BlueprintEvent)

void UFortConfirmationWindow::OnShow()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConfirmationWindow", "OnShow");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortConfirmationWindow.ProcessResult
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EFortDialogResult                       DialogResult                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortConfirmationWindow::ProcessResult(EFortDialogResult DialogResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConfirmationWindow", "ProcessResult");

	Params::FortConfirmationWindow_ProcessResult Parms{};

	Parms.DialogResult = DialogResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortConfirmationWindow.ShowConfirmation
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortDialogDescription&    Description                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortConfirmationWindow::ShowConfirmation(const struct FFortDialogDescription& Description)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConfirmationWindow", "ShowConfirmation");

	Params::FortConfirmationWindow_ShowConfirmation Parms{};

	Parms.Description = std::move(Description);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortErrorDialog.DisplayError
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortErrorInfo&            ErrorInfo_0                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortErrorDialog::DisplayError(const struct FFortErrorInfo& ErrorInfo_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortErrorDialog", "DisplayError");

	Params::FortErrorDialog_DisplayError Parms{};

	Parms.ErrorInfo_0 = std::move(ErrorInfo_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortErrorDialog.DisplaySimpleError
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      ErrorMessage                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortErrorDialog::DisplaySimpleError(const class FText& ErrorMessage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortErrorDialog", "DisplaySimpleError");

	Params::FortErrorDialog_DisplaySimpleError Parms{};

	Parms.ErrorMessage = std::move(ErrorMessage);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortErrorDialog.OnRebuildDialog
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   NewIndex                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortErrorDialog::OnRebuildDialog(int32 NewIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortErrorDialog", "OnRebuildDialog");

	Params::FortErrorDialog_OnRebuildDialog Parms{};

	Parms.NewIndex = NewIndex;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortErrorDialog.ResetErrorInfo
// (Final, Native, Protected, BlueprintCallable)

void UFortErrorDialog::ResetErrorInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortErrorDialog", "ResetErrorInfo");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIStateWidget.OnEnterState
// (Event, Public, BlueprintEvent)
// Parameters:
// EFortUIState                            PreviousUIState                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIStateWidget::OnEnterState(EFortUIState PreviousUIState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIStateWidget", "OnEnterState");

	Params::FortUIStateWidget_OnEnterState Parms{};

	Parms.PreviousUIState = PreviousUIState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortUIStateWidget.OnExitState
// (Event, Public, BlueprintEvent)
// Parameters:
// EFortUIState                            NextUIState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIStateWidget::OnExitState(EFortUIState NextUIState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIStateWidget", "OnExitState");

	Params::FortUIStateWidget_OnExitState Parms{};

	Parms.NextUIState = NextUIState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortVerticalRibbon._BPOnStackDepthChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   NewDepth                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortVerticalRibbon::_BPOnStackDepthChanged(int32 NewDepth)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVerticalRibbon", "_BPOnStackDepthChanged");

	Params::FortVerticalRibbon__BPOnStackDepthChanged Parms{};

	Parms.NewDepth = NewDepth;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortVerticalRibbon.PopContent
// (Final, Native, Public, BlueprintCallable)

void UFortVerticalRibbon::PopContent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVerticalRibbon", "PopContent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortVerticalRibbon.PushContent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWidget*                          NewContent                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortVerticalRibbon::PushContent(class UWidget* NewContent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVerticalRibbon", "PushContent");

	Params::FortVerticalRibbon_PushContent Parms{};

	Parms.NewContent = NewContent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortVerticalRibbon.GetTop
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UWidget*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWidget* UFortVerticalRibbon::GetTop() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVerticalRibbon", "GetTop");

	Params::FortVerticalRibbon_GetTop Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortActorIndicatorWidget.OnIndicatedActorSet
// (Event, Protected, BlueprintEvent)

void UFortActorIndicatorWidget::OnIndicatedActorSet()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortActorIndicatorWidget", "OnIndicatedActorSet");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortItemWidget.BPOnItemChanged
// (Event, Protected, BlueprintEvent)

void UFortItemWidget::BPOnItemChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "BPOnItemChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortItemWidget.BPOnItemSet
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UFortItem*                        NewItem                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemWidget::BPOnItemSet(class UFortItem* NewItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "BPOnItemSet");

	Params::FortItemWidget_BPOnItemSet Parms{};

	Parms.NewItem = NewItem;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortItemWidget.GetItemToCompare
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortItem*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortItem* UFortItemWidget::GetItemToCompare()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetItemToCompare");

	Params::FortItemWidget_GetItemToCompare Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.OnFortItemDestroyed
// (Final, Native, Private)

void UFortItemWidget::OnFortItemDestroyed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "OnFortItemDestroyed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortItemWidget.OnFortItemInvalidated
// (Final, Native, Private)

void UFortItemWidget::OnFortItemInvalidated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "OnFortItemInvalidated");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortItemWidget.OnFortItemUpdated
// (Final, Native, Private)
// Parameters:
// bool                                    bItemChanged                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bAmmoChanged                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bIngredientsChanged                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortItemWidget::OnFortItemUpdated(bool bItemChanged, bool bAmmoChanged, bool bIngredientsChanged)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "OnFortItemUpdated");

	Params::FortItemWidget_OnFortItemUpdated Parms{};

	Parms.bItemChanged = bItemChanged;
	Parms.bAmmoChanged = bAmmoChanged;
	Parms.bIngredientsChanged = bIngredientsChanged;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortItemWidget.SetItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UFortItem*                  InItem                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   QuantityOverride_0                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemWidget::SetItem(const class UFortItem* InItem, int32 QuantityOverride_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "SetItem");

	Params::FortItemWidget_SetItem Parms{};

	Parms.InItem = InItem;
	Parms.QuantityOverride_0 = QuantityOverride_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortItemWidget.SetOnGetItemToCompareDelegate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TDelegate<void(class UFortItem** ItemToCompare)>InDelegate                                             (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UFortItemWidget::SetOnGetItemToCompareDelegate(TDelegate<void(class UFortItem** ItemToCompare)> InDelegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "SetOnGetItemToCompareDelegate");

	Params::FortItemWidget_SetOnGetItemToCompareDelegate Parms{};

	Parms.InDelegate = InDelegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortItemWidget.GetAmmoCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItemWidget::GetAmmoCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetAmmoCount");

	Params::FortItemWidget_GetAmmoCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetDescription
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortItemWidget::GetDescription() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetDescription");

	Params::FortItemWidget_GetDescription Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetDisplayName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortItemWidget::GetDisplayName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetDisplayName");

	Params::FortItemWidget_GetDisplayName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetDurability
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortItemWidget::GetDurability() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetDurability");

	Params::FortItemWidget_GetDurability Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetIconScale
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortItemWidget::GetIconScale() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetIconScale");

	Params::FortItemWidget_GetIconScale Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetIconTexture
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortBrushSize                          InBrushSize                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture*                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture* UFortItemWidget::GetIconTexture(EFortBrushSize InBrushSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetIconTexture");

	Params::FortItemWidget_GetIconTexture Parms{};

	Parms.InBrushSize = InBrushSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortItem*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortItem* UFortItemWidget::GetItem() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetItem");

	Params::FortItemWidget_GetItem Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItemWidget::GetLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetLevel");

	Params::FortItemWidget_GetLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetPulse
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortItemWidget::GetPulse() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetPulse");

	Params::FortItemWidget_GetPulse Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetRarity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortRarity                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortRarity UFortItemWidget::GetRarity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetRarity");

	Params::FortItemWidget_GetRarity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetSecondaryCategoryTexture
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortBrushSize                          InBrushSize                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FSlateBrush                      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FSlateBrush UFortItemWidget::GetSecondaryCategoryTexture(EFortBrushSize InBrushSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetSecondaryCategoryTexture");

	Params::FortItemWidget_GetSecondaryCategoryTexture Parms{};

	Parms.InBrushSize = InBrushSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetStackCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItemWidget::GetStackCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetStackCount");

	Params::FortItemWidget_GetStackCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetTertiaryCategoryTexture
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortBrushSize                          InBrushSize                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FSlateBrush                      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FSlateBrush UFortItemWidget::GetTertiaryCategoryTexture(EFortBrushSize InBrushSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetTertiaryCategoryTexture");

	Params::FortItemWidget_GetTertiaryCategoryTexture Parms{};

	Parms.InBrushSize = InBrushSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.GetType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortItemWidget::GetType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "GetType");

	Params::FortItemWidget_GetType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.HasDurability
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemWidget::HasDurability() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "HasDurability");

	Params::FortItemWidget_HasDurability Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.HasLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemWidget::HasLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "HasLevel");

	Params::FortItemWidget_HasLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.HasSecondaryCategory
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemWidget::HasSecondaryCategory() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "HasSecondaryCategory");

	Params::FortItemWidget_HasSecondaryCategory Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.HasTertiaryCategory
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemWidget::HasTertiaryCategory() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "HasTertiaryCategory");

	Params::FortItemWidget_HasTertiaryCategory Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.IsEquipped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemWidget::IsEquipped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "IsEquipped");

	Params::FortItemWidget_IsEquipped Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.IsInBackpackOverflow
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemWidget::IsInBackpackOverflow() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "IsInBackpackOverflow");

	Params::FortItemWidget_IsInBackpackOverflow Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.IsItemValid
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemWidget::IsItemValid() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "IsItemValid");

	Params::FortItemWidget_IsItemValid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.IsSchematic
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemWidget::IsSchematic() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "IsSchematic");

	Params::FortItemWidget_IsSchematic Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortItemWidget.IsSlotted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemWidget::IsSlotted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemWidget", "IsSlotted");

	Params::FortItemWidget_IsSlotted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortBluGloCounter.OnBluGloQuantityChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// int32                                   Quantity                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBluGloCounter::OnBluGloQuantityChanged(int32 Quantity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBluGloCounter", "OnBluGloQuantityChanged");

	Params::FortBluGloCounter_OnBluGloQuantityChanged Parms{};

	Parms.Quantity = Quantity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortButton.SetCurrentState
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EFortButtonState                        NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortButton::SetCurrentState(EFortButtonState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButton", "SetCurrentState");

	Params::FortButton_SetCurrentState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortButton.SetDisabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InDisable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortButton::SetDisabled(bool InDisable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButton", "SetDisabled");

	Params::FortButton_SetDisabled Parms{};

	Parms.InDisable = InDisable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortButton.SetIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   InIndex                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortButton::SetIndex(int32 InIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButton", "SetIndex");

	Params::FortButton_SetIndex Parms{};

	Parms.InIndex = InIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortButton.SetText
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (Parm, NativeAccessSpecifierPublic)

void UFortButton::SetText(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButton", "SetText");

	Params::FortButton_SetText Parms{};

	Parms.InText = std::move(InText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortButton.GetCurrentState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortButtonState                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortButtonState UFortButton::GetCurrentState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButton", "GetCurrentState");

	Params::FortButton_GetCurrentState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButton.GetDisabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortButton::GetDisabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButton", "GetDisabled");

	Params::FortButton_GetDisabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButton.GetIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortButton::GetIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButton", "GetIndex");

	Params::FortButton_GetIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButton.GetPendingState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortButtonState                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortButtonState UFortButton::GetPendingState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButton", "GetPendingState");

	Params::FortButton_GetPendingState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortButton.GetText
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortButton::GetText() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortButton", "GetText");

	Params::FortButton_GetText Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortTabButton._BPOnSelectedChanged
// (Event, Protected, BlueprintEvent)

void UFortTabButton::_BPOnSelectedChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTabButton", "_BPOnSelectedChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortTabButton.ClearSelection
// (Final, Native, Public, BlueprintCallable)

void UFortTabButton::ClearSelection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTabButton", "ClearSelection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortTabButton.SetSelection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InSelected                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortTabButton::SetSelection(bool InSelected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTabButton", "SetSelection");

	Params::FortTabButton_SetSelection Parms{};

	Parms.InSelected = InSelected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortTabButton.IsSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortTabButton::IsSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTabButton", "IsSelected");

	Params::FortTabButton_IsSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortCapturePointWidget.OnCapturePointDataChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bActivated                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bLocked                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   CapturePercentage                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECaptureState                           CaptureState                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeam                               ControllingTeam                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCapturePointWidget::OnCapturePointDataChanged(bool bActivated, bool bLocked, float CapturePercentage, ECaptureState CaptureState, EFortTeam ControllingTeam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCapturePointWidget", "OnCapturePointDataChanged");

	Params::FortCapturePointWidget_OnCapturePointDataChanged Parms{};

	Parms.bActivated = bActivated;
	Parms.bLocked = bLocked;
	Parms.CapturePercentage = CapturePercentage;
	Parms.CaptureState = CaptureState;
	Parms.ControllingTeam = ControllingTeam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortChatContainer.AttachChatWindowToNativeWidget
// (Final, Native, Public, BlueprintCallable)

void UFortChatContainer::AttachChatWindowToNativeWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortChatContainer", "AttachChatWindowToNativeWidget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortChatContainer.SetNativeWidgetHost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UNativeWidgetHost*                InNativeWidgetHost                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortChatContainer::SetNativeWidgetHost(class UNativeWidgetHost* InNativeWidgetHost)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortChatContainer", "SetNativeWidgetHost");

	Params::FortChatContainer_SetNativeWidgetHost Parms{};

	Parms.InNativeWidgetHost = InNativeWidgetHost;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortItemCollectorWidget.OnItemCollectorChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class ABuildingItemCollectorActor*      OutItemCollector                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemCollectorWidget::OnItemCollectorChanged(class ABuildingItemCollectorActor* OutItemCollector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemCollectorWidget", "OnItemCollectorChanged");

	Params::FortItemCollectorWidget_OnItemCollectorChanged Parms{};

	Parms.OutItemCollector = OutItemCollector;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortItemCollectorWidget.OnItemCollectorStateChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// EFortItemCollectorState                 ItemCollectorState                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemCollectorWidget::OnItemCollectorStateChanged(EFortItemCollectorState ItemCollectorState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemCollectorWidget", "OnItemCollectorStateChanged");

	Params::FortItemCollectorWidget_OnItemCollectorStateChanged Parms{};

	Parms.ItemCollectorState = ItemCollectorState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortItemCollectorWidget.OnItemCollectorValuesChanged
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// TArray<int32>&                          DepositAmounts                                         (Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<int32>&                          DepositGoals                                           (Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UFortItemCollectorWidget::OnItemCollectorValuesChanged(TArray<int32>& DepositAmounts, TArray<int32>& DepositGoals)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemCollectorWidget", "OnItemCollectorValuesChanged");

	Params::FortItemCollectorWidget_OnItemCollectorValuesChanged Parms{};

	Parms.DepositAmounts = std::move(DepositAmounts);
	Parms.DepositGoals = std::move(DepositGoals);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	DepositAmounts = std::move(Parms.DepositAmounts);
	DepositGoals = std::move(Parms.DepositGoals);
}


// Function FortniteUI.FortListItem.Private_OnExpanderArrowShiftClicked
// (Event, Public, BlueprintEvent)

void UFortListItem::Private_OnExpanderArrowShiftClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListItem", "Private_OnExpanderArrowShiftClicked");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortListItem.SetData
// (Event, Public, BlueprintEvent)
// Parameters:
// class UObject*                          InData                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortListItem::SetData(class UObject* InData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListItem", "SetData");

	Params::FortListItem_SetData Parms{};

	Parms.InData = InData;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortListItem.SetIndexInList
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   InIndexInList                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortListItem::SetIndexInList(int32 InIndexInList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListItem", "SetIndexInList");

	Params::FortListItem_SetIndexInList Parms{};

	Parms.InIndexInList = InIndexInList;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortListItem.SetSelected
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bSelected                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortListItem::SetSelected(bool bSelected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListItem", "SetSelected");

	Params::FortListItem_SetSelected Parms{};

	Parms.bSelected = bSelected;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortListItem.ToggleExpansion
// (Event, Public, BlueprintEvent)

void UFortListItem::ToggleExpansion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListItem", "ToggleExpansion");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortListItem.DoesItemHaveChildren
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortListItem::DoesItemHaveChildren() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListItem", "DoesItemHaveChildren");

	Params::FortListItem_DoesItemHaveChildren Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortListItem.GetIndentLevel
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortListItem::GetIndentLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListItem", "GetIndentLevel");

	Params::FortListItem_GetIndentLevel Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortListItem.GetSelectionMode
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// ESelectionMode                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESelectionMode UFortListItem::GetSelectionMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListItem", "GetSelectionMode");

	Params::FortListItem_GetSelectionMode Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortListItem.IsItemExpanded
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortListItem::IsItemExpanded() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortListItem", "IsItemExpanded");

	Params::FortListItem_IsItemExpanded Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortLoginRewardItem.CreateItemTooltip
// (Final, Native, Public, BlueprintCallable)

void UFortLoginRewardItem::CreateItemTooltip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewardItem", "CreateItemTooltip");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginRewardItem.SetFortItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortItem*                        InFortItem                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortLoginRewardItem::SetFortItem(class UFortItem* InFortItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewardItem", "SetFortItem");

	Params::FortLoginRewardItem_SetFortItem Parms{};

	Parms.InFortItem = InFortItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginRewardItem.SetHighValueItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInHighValueItem                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortLoginRewardItem::SetHighValueItem(bool bInHighValueItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewardItem", "SetHighValueItem");

	Params::FortLoginRewardItem_SetHighValueItem Parms{};

	Parms.bInHighValueItem = bInHighValueItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginRewardItem.SetLoginRewardDay
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   InLoginRewardDay                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortLoginRewardItem::SetLoginRewardDay(int32 InLoginRewardDay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewardItem", "SetLoginRewardDay");

	Params::FortLoginRewardItem_SetLoginRewardDay Parms{};

	Parms.InLoginRewardDay = InLoginRewardDay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginRewardItem.SetPlayClaimAnimation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInPlayClaimAnimation                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortLoginRewardItem::SetPlayClaimAnimation(bool bInPlayClaimAnimation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewardItem", "SetPlayClaimAnimation");

	Params::FortLoginRewardItem_SetPlayClaimAnimation Parms{};

	Parms.bInPlayClaimAnimation = bInPlayClaimAnimation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginRewardItem.SetUnclaimedItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInUnclaimedItem                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortLoginRewardItem::SetUnclaimedItem(bool bInUnclaimedItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewardItem", "SetUnclaimedItem");

	Params::FortLoginRewardItem_SetUnclaimedItem Parms{};

	Parms.bInUnclaimedItem = bInUnclaimedItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginRewards.CreateLoginRewardWidget
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UFortLoginRewardItem*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortLoginRewardItem* UFortLoginRewards::CreateLoginRewardWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewards", "CreateLoginRewardWidget");

	Params::FortLoginRewards_CreateLoginRewardWidget Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteUI.FortLoginRewards.DisablePaging
// (Event, Protected, BlueprintEvent)
// Parameters:
// EPageDirection                          Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortLoginRewards::DisablePaging(EPageDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewards", "DisablePaging");

	Params::FortLoginRewards_DisablePaging Parms{};

	Parms.Direction = Direction;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortLoginRewards.EnablePaging
// (Event, Protected, BlueprintEvent)
// Parameters:
// EPageDirection                          Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortLoginRewards::EnablePaging(EPageDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewards", "EnablePaging");

	Params::FortLoginRewards_EnablePaging Parms{};

	Parms.Direction = Direction;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortLoginRewards.HandlePageLeft
// (Final, Native, Public, BlueprintCallable)

void UFortLoginRewards::HandlePageLeft()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewards", "HandlePageLeft");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginRewards.HandlePageRight
// (Final, Native, Public, BlueprintCallable)

void UFortLoginRewards::HandlePageRight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewards", "HandlePageRight");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginRewards.SetGridPanel
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UUniformGridPanel*                InGridPanel                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortLoginRewards::SetGridPanel(class UUniformGridPanel* InGridPanel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewards", "SetGridPanel");

	Params::FortLoginRewards_SetGridPanel Parms{};

	Parms.InGridPanel = InGridPanel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginRewards.GetCurrentLoginDays
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortLoginRewards::GetCurrentLoginDays() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewards", "GetCurrentLoginDays");

	Params::FortLoginRewards_GetCurrentLoginDays Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortLoginRewards.GetCurrentPage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortLoginRewards::GetCurrentPage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginRewards", "GetCurrentPage");

	Params::FortLoginRewards_GetCurrentPage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortLoginWindow.Login
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class FString&                    InEmail                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InPassword                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRemember                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortLoginWindow::Login(const class FString& InEmail, const class FString& InPassword, bool bRemember)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginWindow", "Login");

	Params::FortLoginWindow_Login Parms{};

	Parms.InEmail = std::move(InEmail);
	Parms.InPassword = std::move(InPassword);
	Parms.bRemember = bRemember;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortLoginWindow.OnLoginStatusChanged
// (Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// EUILoginStatus                          NewStatus                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      InMessage                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortLoginWindow::OnLoginStatusChanged(EUILoginStatus NewStatus, const class FText& InMessage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginWindow", "OnLoginStatusChanged");

	Params::FortLoginWindow_OnLoginStatusChanged Parms{};

	Parms.NewStatus = NewStatus;
	Parms.InMessage = std::move(InMessage);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortLoginWindow.GetDefaultEmail
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UFortLoginWindow::GetDefaultEmail() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginWindow", "GetDefaultEmail");

	Params::FortLoginWindow_GetDefaultEmail Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortLoginWindow.GetLoginStatusText
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortLoginWindow::GetLoginStatusText() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginWindow", "GetLoginStatusText");

	Params::FortLoginWindow_GetLoginStatusText Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortLoginWindow.IsRememberMeChecked
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortLoginWindow::IsRememberMeChecked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginWindow", "IsRememberMeChecked");

	Params::FortLoginWindow_IsRememberMeChecked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortLoginWindow.ShouldShowLoginButton
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    InEmail                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InPassword                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortLoginWindow::ShouldShowLoginButton(const class FString& InEmail, const class FString& InPassword) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLoginWindow", "ShouldShowLoginButton");

	Params::FortLoginWindow_ShouldShowLoginButton Parms{};

	Parms.InEmail = std::move(InEmail);
	Parms.InPassword = std::move(InPassword);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortMovieWidget.RequestPlayMovie
// (Final, Native, Public, BlueprintCallable)

void UFortMovieWidget::RequestPlayMovie()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMovieWidget", "RequestPlayMovie");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortMovieWidget.RequestStopMovie
// (Final, Native, Public, BlueprintCallable)

void UFortMovieWidget::RequestStopMovie()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMovieWidget", "RequestStopMovie");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortMovieWidget.SetMediaPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMediaPlayer*                     NewMediaPlayer                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMovieWidget::SetMediaPlayer(class UMediaPlayer* NewMediaPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMovieWidget", "SetMediaPlayer");

	Params::FortMovieWidget_SetMediaPlayer Parms{};

	Parms.NewMediaPlayer = NewMediaPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortMovieWidget.GetMediaPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMediaPlayer*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMediaPlayer* UFortMovieWidget::GetMediaPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMovieWidget", "GetMediaPlayer");

	Params::FortMovieWidget_GetMediaPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortSocialItemWidget.SetSocialItem
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UFortSocialItem*                  InSocialItem                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortSocialItemWidget::SetSocialItem(class UFortSocialItem* InSocialItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSocialItemWidget", "SetSocialItem");

	Params::FortSocialItemWidget_SetSocialItem Parms{};

	Parms.InSocialItem = InSocialItem;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortTutorialOverlay.OpenBannerMenu
// (Final, Native, Private)

void UFortTutorialOverlay::OpenBannerMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialOverlay", "OpenBannerMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortTutorialOverlay.SetTutorialNotificationActive
// (Final, Native, Private)
// Parameters:
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortTutorialOverlay::SetTutorialNotificationActive(bool bActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialOverlay", "SetTutorialNotificationActive");

	Params::FortTutorialOverlay_SetTutorialNotificationActive Parms{};

	Parms.bActive = bActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortTutorialOverlay.SetupNativeWidgets
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UNamedSlot*                       NativeSlot                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialOverlay::SetupNativeWidgets(class UNamedSlot* NativeSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialOverlay", "SetupNativeWidgets");

	Params::FortTutorialOverlay_SetupNativeWidgets Parms{};

	Parms.NativeSlot = NativeSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortTutorialScreen.OnHideTutorialScreen
// (Event, Public, BlueprintEvent)

void UFortTutorialScreen::OnHideTutorialScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialScreen", "OnHideTutorialScreen");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortTutorialScreen.OnShowTutorialScreen
// (Event, Public, BlueprintEvent)
// Parameters:
// class UTexture2D*                       Image                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialScreen::OnShowTutorialScreen(class UTexture2D* Image)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialScreen", "OnShowTutorialScreen");

	Params::FortTutorialScreen_OnShowTutorialScreen Parms{};

	Parms.Image = Image;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortTutorialScreen.PlayerFinished
// (Final, Native, Protected, BlueprintCallable)

void UFortTutorialScreen::PlayerFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialScreen", "PlayerFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIManagerWidget.CreateUIStateTrigger
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UFortUIStateTrigger>  Class_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortUIStateTrigger*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortUIStateTrigger* UFortUIManagerWidget::CreateUIStateTrigger(TSubclassOf<class UFortUIStateTrigger> Class_0, class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortUIManagerWidget", "CreateUIStateTrigger");

	Params::FortUIManagerWidget_CreateUIStateTrigger Parms{};

	Parms.Class_0 = Class_0;
	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortUIManagerWidget.GetUIManagerWidget
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortUIManagerWidget*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortUIManagerWidget* UFortUIManagerWidget::GetUIManagerWidget(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortUIManagerWidget", "GetUIManagerWidget");

	Params::FortUIManagerWidget_GetUIManagerWidget Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortUIManagerWidget.KillConfirmationDialog
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIManagerWidget::KillConfirmationDialog(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortUIManagerWidget", "KillConfirmationDialog");

	Params::FortUIManagerWidget_KillConfirmationDialog Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIManagerWidget.ShowErrorDialog
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      OperationDesc                                          (Parm, NativeAccessSpecifierPublic)
// const class FText&                      DisplayMessage                                         (Parm, NativeAccessSpecifierPublic)
// const class FString&                    ErrorCode                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIManagerWidget::ShowErrorDialog(class UObject* WorldContextObject, const class FText& OperationDesc, const class FText& DisplayMessage, const class FString& ErrorCode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortUIManagerWidget", "ShowErrorDialog");

	Params::FortUIManagerWidget_ShowErrorDialog Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.OperationDesc = std::move(OperationDesc);
	Parms.DisplayMessage = std::move(DisplayMessage);
	Parms.ErrorCode = std::move(ErrorCode);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIManagerWidget.DisplayErrorDialog
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FFortErrorInfo&            Info                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortUIManagerWidget::DisplayErrorDialog(const struct FFortErrorInfo& Info)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "DisplayErrorDialog");

	Params::FortUIManagerWidget_DisplayErrorDialog Parms{};

	Parms.Info = std::move(Info);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortUIManagerWidget.DisplayStateContent
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bDisplay                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortUIManagerWidget::DisplayStateContent(bool bDisplay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "DisplayStateContent");

	Params::FortUIManagerWidget_DisplayStateContent Parms{};

	Parms.bDisplay = bDisplay;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortUIManagerWidget.OnShowConfirmation
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FFortDialogDescription&    Description                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortUIManagerWidget::OnShowConfirmation(const struct FFortDialogDescription& Description)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "OnShowConfirmation");

	Params::FortUIManagerWidget_OnShowConfirmation Parms{};

	Parms.Description = std::move(Description);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortUIManagerWidget.OnStateStarted
// (Event, Public, BlueprintEvent)

void UFortUIManagerWidget::OnStateStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "OnStateStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortUIManagerWidget.RegisterStateTrigger
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortUIStateTrigger*              StateTrigger                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIManagerWidget::RegisterStateTrigger(class UFortUIStateTrigger* StateTrigger)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "RegisterStateTrigger");

	Params::FortUIManagerWidget_RegisterStateTrigger Parms{};

	Parms.StateTrigger = StateTrigger;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIManagerWidget.SetStateContentDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bDisplay                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortUIManagerWidget::SetStateContentDisplayed(bool bDisplay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "SetStateContentDisplayed");

	Params::FortUIManagerWidget_SetStateContentDisplayed Parms{};

	Parms.bDisplay = bDisplay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIManagerWidget.UnregisterStateTrigger
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortUIStateTrigger*              TriggerToRemove                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIManagerWidget::UnregisterStateTrigger(class UFortUIStateTrigger* TriggerToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "UnregisterStateTrigger");

	Params::FortUIManagerWidget_UnregisterStateTrigger Parms{};

	Parms.TriggerToRemove = TriggerToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIManagerWidget.UpdateStateWidgetContent
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UFortUIStateWidget*               StateWidget                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIManagerWidget::UpdateStateWidgetContent(class UFortUIStateWidget* StateWidget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "UpdateStateWidgetContent");

	Params::FortUIManagerWidget_UpdateStateWidgetContent Parms{};

	Parms.StateWidget = StateWidget;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortUIManagerWidget._BPGetCurrentUIState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortUIState                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortUIState UFortUIManagerWidget::_BPGetCurrentUIState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "_BPGetCurrentUIState");

	Params::FortUIManagerWidget__BPGetCurrentUIState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortUIManagerWidget.GetCurrentUIStateWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortUIStateWidget*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortUIStateWidget* UFortUIManagerWidget::GetCurrentUIStateWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "GetCurrentUIStateWidget");

	Params::FortUIManagerWidget_GetCurrentUIStateWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortUIManagerWidget.IsStateContentDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortUIManagerWidget::IsStateContentDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerWidget", "IsStateContentDisplayed");

	Params::FortUIManagerWidget_IsStateContentDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortUIMessageItemWidget.OnRemoveRequested
// (Event, Protected, BlueprintEvent)

void UFortUIMessageItemWidget::OnRemoveRequested()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIMessageItemWidget", "OnRemoveRequested");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortUIMessageItemWidget.RequestRemove
// (Final, Native, Public, BlueprintCallable)

void UFortUIMessageItemWidget::RequestRemove()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIMessageItemWidget", "RequestRemove");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortUIMessageItemWidget.StackItem
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UFortUIMessageItemWidget*         StackedItem                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortUIMessageItemWidget::StackItem(class UFortUIMessageItemWidget* StackedItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIMessageItemWidget", "StackItem");

	Params::FortUIMessageItemWidget_StackItem Parms{};

	Parms.StackedItem = StackedItem;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteUI.FortVaultDetailsWidget._BPOnNewItemSet
// (Event, Protected, BlueprintEvent)

void UFortVaultDetailsWidget::_BPOnNewItemSet()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "_BPOnNewItemSet");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortVaultDetailsWidget.GetInfo
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// struct FVaultDetailsInfo                ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FVaultDetailsInfo UFortVaultDetailsWidget::GetInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "GetInfo");

	Params::FortVaultDetailsWidget_GetInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortVaultDetailsWidget.GetItem
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UFortItem*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortItem* UFortVaultDetailsWidget::GetItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "GetItem");

	Params::FortVaultDetailsWidget_GetItem Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortVaultDetailsWidget.GetLevelProperty
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// struct FVaultPropertyInfo               ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FVaultPropertyInfo UFortVaultDetailsWidget::GetLevelProperty()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "GetLevelProperty");

	Params::FortVaultDetailsWidget_GetLevelProperty Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortVaultDetailsWidget.GetMaxLevelProperty
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// struct FVaultPropertyInfo               ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FVaultPropertyInfo UFortVaultDetailsWidget::GetMaxLevelProperty()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "GetMaxLevelProperty");

	Params::FortVaultDetailsWidget_GetMaxLevelProperty Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortVaultDetailsWidget.GetProperties
// (Final, Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<struct FVaultPropertyInfo>*      Properties                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    bWithUpgradeData                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortVaultDetailsWidget::GetProperties(TArray<struct FVaultPropertyInfo>* Properties, bool bWithUpgradeData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "GetProperties");

	Params::FortVaultDetailsWidget_GetProperties Parms{};

	Parms.bWithUpgradeData = bWithUpgradeData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Properties != nullptr)
		*Properties = std::move(Parms.Properties);
}


// Function FortniteUI.FortVaultDetailsWidget.HasPendingCustomization
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortVaultDetailsWidget::HasPendingCustomization()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "HasPendingCustomization");

	Params::FortVaultDetailsWidget_HasPendingCustomization Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortVaultDetailsWidget.HasPendingUpgrade
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortVaultDetailsWidget::HasPendingUpgrade()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "HasPendingUpgrade");

	Params::FortVaultDetailsWidget_HasPendingUpgrade Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteUI.FortVaultDetailsWidget.SetItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UFortItem*                  InItem                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortVaultDetailsWidget::SetItem(const class UFortItem* InItem, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "SetItem");

	Params::FortVaultDetailsWidget_SetItem Parms{};

	Parms.InItem = InItem;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortVaultDetailsWidget.SetItemForCommand
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UFortItem*                  InItem                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EVaultCommandType                       InCommand                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortVaultDetailsWidget::SetItemForCommand(const class UFortItem* InItem, EVaultCommandType InCommand, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "SetItemForCommand");

	Params::FortVaultDetailsWidget_SetItemForCommand Parms{};

	Parms.InItem = InItem;
	Parms.InCommand = InCommand;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteUI.FortVaultDetailsWidget.GetAlterationSlots
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FVaultAlterationInfo>*    Slots                                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortVaultDetailsWidget::GetAlterationSlots(TArray<struct FVaultAlterationInfo>* Slots) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultDetailsWidget", "GetAlterationSlots");

	Params::FortVaultDetailsWidget_GetAlterationSlots Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Slots != nullptr)
		*Slots = std::move(Parms.Slots);
}


// Function FortniteUI.FortVaultWidget._BPOnContentUpdated
// (Event, Protected, BlueprintEvent)

void UFortVaultWidget::_BPOnContentUpdated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultWidget", "_BPOnContentUpdated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteUI.FortVaultWidget.GetItemList
// (Final, Native, Protected, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortAccountItem*>*        OutItemList                                            (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// EVaultContentType                       InContentType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVaultContentDetails&      Details                                                (Parm, NativeAccessSpecifierPublic)

void UFortVaultWidget::GetItemList(TArray<class UFortAccountItem*>* OutItemList, EVaultContentType InContentType, const struct FVaultContentDetails& Details) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultWidget", "GetItemList");

	Params::FortVaultWidget_GetItemList Parms{};

	Parms.InContentType = InContentType;
	Parms.Details = std::move(Details);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutItemList != nullptr)
		*OutItemList = std::move(Parms.OutItemList);
}


// Function FortniteUI.FortVaultWidget.IsSupportedSortType
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EVaultContentSortType                   InSortType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EVaultContentType                       InContentType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortInventoryFilter                    InContentSubType                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortVaultWidget::IsSupportedSortType(EVaultContentSortType InSortType, EVaultContentType InContentType, EFortInventoryFilter InContentSubType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortVaultWidget", "IsSupportedSortType");

	Params::FortVaultWidget_IsSupportedSortType Parms{};

	Parms.InSortType = InSortType;
	Parms.InContentType = InContentType;
	Parms.InContentSubType = InContentSubType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}

}

#pragma pack(pop)