#pragma once

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

// Package: UINavigation

#include "Basic.hpp"

#include "UINavigation_classes.hpp"
#include "UINavigation_parameters.hpp"


SDK_NAMESPACE_START

// Function UINavigation.UINavComponentAction.ExecuteAction
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavComponentAction::ExecuteAction(class UUINavComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponentAction", "ExecuteAction");

	Params::UINavComponentAction_ExecuteAction Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.ConfigureUINavPC
// (Final, Native, Protected, BlueprintCallable)

void UUINavWidget::ConfigureUINavPC()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "ConfigureUINavPC");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.GetInitialFocusComponent
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UUINavComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavComponent* UUINavWidget::GetInitialFocusComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "GetInitialFocusComponent");

	Params::UINavWidget_GetInitialFocusComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavWidget.GetMostOuterUINavWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UUINavWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavWidget* UUINavWidget::GetMostOuterUINavWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "GetMostOuterUINavWidget");

	Params::UINavWidget_GetMostOuterUINavWidget Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavWidget.GetScrollBoxToFocus
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UScrollBox*                       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UScrollBox* UUINavWidget::GetScrollBoxToFocus()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "GetScrollBoxToFocus");

	Params::UINavWidget_GetScrollBoxToFocus Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavWidget.GoToBuiltWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUINavWidget*                     NewWidget                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bRemoveParent                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDestroyParent                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ZOrder                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavWidget* UUINavWidget::GoToBuiltWidget(class UUINavWidget* NewWidget, const bool bRemoveParent, const bool bDestroyParent, const int32 ZOrder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "GoToBuiltWidget");

	Params::UINavWidget_GoToBuiltWidget Parms{};

	Parms.NewWidget = NewWidget;
	Parms.bRemoveParent = bRemoveParent;
	Parms.bDestroyParent = bDestroyParent;
	Parms.ZOrder = ZOrder;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavWidget.GoToNextSection
// (Final, Native, Protected, BlueprintCallable)

void UUINavWidget::GoToNextSection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "GoToNextSection");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.GoToPreviousSection
// (Final, Native, Protected, BlueprintCallable)

void UUINavWidget::GoToPreviousSection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "GoToPreviousSection");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.GoToPromptWidget
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TSubclassOf<class UUINavPromptWidget>   NewWidgetClass                                         (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(const class UPromptDataBase* PromptData)>&Event                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      title                                                  (ConstParm, Parm, NativeAccessSpecifierPublic)
// const class FText&                      Message                                                (ConstParm, Parm, NativeAccessSpecifierPublic)
// const bool                              bRemoveParent                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ZOrder                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavWidget* UUINavWidget::GoToPromptWidget(TSubclassOf<class UUINavPromptWidget> NewWidgetClass, const TDelegate<void(const class UPromptDataBase* PromptData)>& Event, const class FText& title, const class FText& Message, const bool bRemoveParent, const int32 ZOrder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "GoToPromptWidget");

	Params::UINavWidget_GoToPromptWidget Parms{};

	Parms.NewWidgetClass = NewWidgetClass;
	Parms.Event = Event;
	Parms.title = std::move(title);
	Parms.Message = std::move(Message);
	Parms.bRemoveParent = bRemoveParent;
	Parms.ZOrder = ZOrder;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavWidget.GoToSection
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const int32                             SectionIndex                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::GoToSection(const int32 SectionIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "GoToSection");

	Params::UINavWidget_GoToSection Parms{};

	Parms.SectionIndex = SectionIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.GoToWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UUINavWidget>         NewWidgetClass                                         (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bRemoveParent                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDestroyParent                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ZOrder                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavWidget* UUINavWidget::GoToWidget(TSubclassOf<class UUINavWidget> NewWidgetClass, const bool bRemoveParent, const bool bDestroyParent, const int32 ZOrder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "GoToWidget");

	Params::UINavWidget_GoToWidget Parms{};

	Parms.NewWidgetClass = NewWidgetClass;
	Parms.bRemoveParent = bRemoveParent;
	Parms.bDestroyParent = bDestroyParent;
	Parms.ZOrder = ZOrder;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavWidget.IsSelectorValid
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavWidget::IsSelectorValid()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "IsSelectorValid");

	Params::UINavWidget_IsSelectorValid Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavWidget.IsSelectorVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavWidget::IsSelectorVisible()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "IsSelectorVisible");

	Params::UINavWidget_IsSelectorVisible Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavWidget.OnChangedSection
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const int32                             FromIndex                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ToIndex                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnChangedSection(const int32 FromIndex, const int32 ToIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnChangedSection");

	Params::UINavWidget_OnChangedSection Parms{};

	Parms.FromIndex = FromIndex;
	Parms.ToIndex = ToIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnChildReturn
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavWidget::OnChildReturn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnChildReturn");

	Params::UINavWidget_OnChildReturn Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavWidget.OnGainedNavigation
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavWidget*                     PreviousActiveWidget                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bFromChild                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnGainedNavigation(class UUINavWidget* PreviousActiveWidget, const bool bFromChild)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnGainedNavigation");

	Params::UINavWidget_OnGainedNavigation Parms{};

	Parms.PreviousActiveWidget = PreviousActiveWidget;
	Parms.bFromChild = bFromChild;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnHorizCompNavigateLeft
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnHorizCompNavigateLeft(class UUINavComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnHorizCompNavigateLeft");

	Params::UINavWidget_OnHorizCompNavigateLeft Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnHorizCompNavigateRight
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnHorizCompNavigateRight(class UUINavComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnHorizCompNavigateRight");

	Params::UINavWidget_OnHorizCompNavigateRight Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnHorizCompUpdated
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnHorizCompUpdated(class UUINavComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnHorizCompUpdated");

	Params::UINavWidget_OnHorizCompUpdated Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnInputChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const EInputType                        From                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputType                        To                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnInputChanged(const EInputType From, const EInputType To)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnInputChanged");

	Params::UINavWidget_OnInputChanged Parms{};

	Parms.From = From;
	Parms.To = To;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnLostNavigation
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavWidget*                     NewActiveWidget                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bToChild                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnLostNavigation(class UUINavWidget* NewActiveWidget, const bool bToChild)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnLostNavigation");

	Params::UINavWidget_OnLostNavigation Parms{};

	Parms.NewActiveWidget = NewActiveWidget;
	Parms.bToChild = bToChild;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnNavigate
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavComponent*                  FromComponent                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavComponent*                  ToComponent                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnNavigate(class UUINavComponent* FromComponent, class UUINavComponent* ToComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnNavigate");

	Params::UINavWidget_OnNavigate Parms{};

	Parms.FromComponent = FromComponent;
	Parms.ToComponent = ToComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnNext
// (Native, Event, Public, BlueprintEvent)

void UUINavWidget::OnNext()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnNext");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnPrevious
// (Native, Event, Public, BlueprintEvent)

void UUINavWidget::OnPrevious()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnPrevious");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnReturn
// (Native, Event, Public, BlueprintEvent)

void UUINavWidget::OnReturn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnReturn");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed1
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed1()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed1");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed10
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed10()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed10");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed2
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed2()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed2");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed3
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed3()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed3");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed4
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed4()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed4");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed5
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed5()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed5");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed6
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed6()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed6");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed7
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed7()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed7");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed8
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed8()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed8");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSectionButtonPressed9
// (Final, Native, Protected)

void UUINavWidget::OnSectionButtonPressed9()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSectionButtonPressed9");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSelect
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnSelect(class UUINavComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSelect");

	Params::UINavWidget_OnSelect Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnSetupCompleted
// (Native, Event, Public, BlueprintEvent)

void UUINavWidget::OnSetupCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnSetupCompleted");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnStartSelect
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnStartSelect(class UUINavComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnStartSelect");

	Params::UINavWidget_OnStartSelect Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnStopSelect
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnStopSelect(class UUINavComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnStopSelect");

	Params::UINavWidget_OnStopSelect Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.OnThumbstickCursorInput
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector2D&                 ThumbstickDelta                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::OnThumbstickCursorInput(const struct FVector2D& ThumbstickDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "OnThumbstickCursorInput");

	Params::UINavWidget_OnThumbstickCursorInput Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.PreSetup
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const bool                              bFirstSetup                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::PreSetup(const bool bFirstSetup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "PreSetup");

	Params::UINavWidget_PreSetup Parms{};

	Parms.bFirstSetup = bFirstSetup;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.ReturnToParent
// (Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bRemoveAllParents                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ZOrder                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::ReturnToParent(const bool bRemoveAllParents, const int32 ZOrder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "ReturnToParent");

	Params::UINavWidget_ReturnToParent Parms{};

	Parms.bRemoveAllParents = bRemoveAllParents;
	Parms.ZOrder = ZOrder;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.SetSelectorScale
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 NewScale                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::SetSelectorScale(const struct FVector2D& NewScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "SetSelectorScale");

	Params::UINavWidget_SetSelectorScale Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.SetSelectorVisible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bVisible                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::SetSelectorVisible(const bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "SetSelectorVisible");

	Params::UINavWidget_SetSelectorVisible Parms{};

	Parms.bVisible = bVisible;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.UpdateSelectorLocation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUINavComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavWidget::UpdateSelectorLocation(class UUINavComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "UpdateSelectorLocation");

	Params::UINavWidget_UpdateSelectorLocation Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavWidget.IsRebindingInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavWidget::IsRebindingInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavWidget", "IsRebindingInput");

	Params::UINavWidget_IsRebindingInput Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPromptWidget.ExecuteCallback
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPromptDataBase*                  InPromptData                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPromptWidget::ExecuteCallback(class UPromptDataBase* InPromptData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPromptWidget", "ExecuteCallback");

	Params::UINavPromptWidget_ExecuteCallback Parms{};

	Parms.InPromptData = InPromptData;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPromptWidget.ProcessPromptWidgetSelected
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UPromptDataBase*                  InPromptData                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPromptWidget::ProcessPromptWidgetSelected(class UPromptDataBase* InPromptData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPromptWidget", "ProcessPromptWidgetSelected");

	Params::UINavPromptWidget_ProcessPromptWidgetSelected Parms{};

	Parms.InPromptData = InPromptData;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPromptWidget.SetCallback
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void(const class UPromptDataBase* PromptData)>&InCallback                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPromptWidget::SetCallback(const TDelegate<void(const class UPromptDataBase* PromptData)>& InCallback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPromptWidget", "SetCallback");

	Params::UINavPromptWidget_SetCallback Parms{};

	Parms.InCallback = InCallback;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPromptWidget.IsAcceptComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UUINavComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPromptWidget::IsAcceptComponent(class UUINavComponent* Component) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPromptWidget", "IsAcceptComponent");

	Params::UINavPromptWidget_IsAcceptComponent Parms{};

	Parms.Component = Component;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.SwapKeysWidget.NotifySwapResult
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bSwap                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USwapKeysWidget::NotifySwapResult(const bool bSwap)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapKeysWidget", "NotifySwapResult");

	Params::SwapKeysWidget_NotifySwapResult Parms{};

	Parms.bSwap = bSwap;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.ApplyStyleRowToText
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class FText&                      Text                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FString&                    StyleRowName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UUINavBlueprintFunctionLibrary::ApplyStyleRowToText(const class FText& Text, const class FString& StyleRowName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "ApplyStyleRowToText");

	Params::UINavBlueprintFunctionLibrary_ApplyStyleRowToText Parms{};

	Parms.Text = std::move(Text);
	Parms.StyleRowName = std::move(StyleRowName);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.CreateBinaryPromptData
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const bool                              bAccept                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPromptDataBinary*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPromptDataBinary* UUINavBlueprintFunctionLibrary::CreateBinaryPromptData(const bool bAccept)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "CreateBinaryPromptData");

	Params::UINavBlueprintFunctionLibrary_CreateBinaryPromptData Parms{};

	Parms.bAccept = bAccept;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.FindWidgetOfClassesInWidget
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UWidget*                          Widget                                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<TSubclassOf<class UWidget>>&WidgetClasses                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
// class UWidget*                          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWidget* UUINavBlueprintFunctionLibrary::FindWidgetOfClassesInWidget(class UWidget* Widget, const TArray<TSubclassOf<class UWidget>>& WidgetClasses)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "FindWidgetOfClassesInWidget");

	Params::UINavBlueprintFunctionLibrary_FindWidgetOfClassesInWidget Parms{};

	Parms.Widget = Widget;
	Parms.WidgetClasses = std::move(WidgetClasses);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetFirstWidgetInUserWidget
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UUserWidget*                UserWidget                                             (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWidget*                          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWidget* UUINavBlueprintFunctionLibrary::GetFirstWidgetInUserWidget(const class UUserWidget* UserWidget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetFirstWidgetInUserWidget");

	Params::UINavBlueprintFunctionLibrary_GetFirstWidgetInUserWidget Parms{};

	Parms.UserWidget = UserWidget;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetIndexInPanelWidget
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UWidget*                    Widget                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UPanelWidget>         PanelWidgetSubclass                                    (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UUINavBlueprintFunctionLibrary::GetIndexInPanelWidget(const class UWidget* Widget, TSubclassOf<class UPanelWidget> PanelWidgetSubclass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetIndexInPanelWidget");

	Params::UINavBlueprintFunctionLibrary_GetIndexInPanelWidget Parms{};

	Parms.Widget = Widget;
	Parms.PanelWidgetSubclass = PanelWidgetSubclass;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetIndexInUniformGridWidget
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UWidget*                    Widget                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  Column                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  Row                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavBlueprintFunctionLibrary::GetIndexInUniformGridWidget(const class UWidget* Widget, int32* Column, int32* Row)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetIndexInUniformGridWidget");

	Params::UINavBlueprintFunctionLibrary_GetIndexInUniformGridWidget Parms{};

	Parms.Widget = Widget;

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function UINavigation.UINavBlueprintFunctionLibrary.GetPanelWidgetChild
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UWidget*                    Widget                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ChildIndex                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWidget*                          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWidget* UUINavBlueprintFunctionLibrary::GetPanelWidgetChild(const class UWidget* Widget, const int32 ChildIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetPanelWidgetChild");

	Params::UINavBlueprintFunctionLibrary_GetPanelWidgetChild Parms{};

	Parms.Widget = Widget;
	Parms.ChildIndex = ChildIndex;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetParentPanelWidget
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UWidget*                    Widget                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UPanelWidget>         PanelWidgetSubclass                                    (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPanelWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPanelWidget* UUINavBlueprintFunctionLibrary::GetParentPanelWidget(const class UWidget* Widget, TSubclassOf<class UPanelWidget> PanelWidgetSubclass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetParentPanelWidget");

	Params::UINavBlueprintFunctionLibrary_GetParentPanelWidget Parms{};

	Parms.Widget = Widget;
	Parms.PanelWidgetSubclass = PanelWidgetSubclass;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetPostProcessSettings
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class FString&                    Variable                                               (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UUINavBlueprintFunctionLibrary::GetPostProcessSettings(const class FString& Variable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetPostProcessSettings");

	Params::UINavBlueprintFunctionLibrary_GetPostProcessSettings Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetRawTextFromRichText
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class FText&                      RichText                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UUINavBlueprintFunctionLibrary::GetRawTextFromRichText(const class FText& RichText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetRawTextFromRichText");

	Params::UINavBlueprintFunctionLibrary_GetRawTextFromRichText Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetSoundClassVolume
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class USoundClass*                      TargetClass                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UUINavBlueprintFunctionLibrary::GetSoundClassVolume(class USoundClass* TargetClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetSoundClassVolume");

	Params::UINavBlueprintFunctionLibrary_GetSoundClassVolume Parms{};

	Parms.TargetClass = TargetClass;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetUINavSettings
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UUINavSettings*             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UUINavSettings* UUINavBlueprintFunctionLibrary::GetUINavSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetUINavSettings");

	Params::UINavBlueprintFunctionLibrary_GetUINavSettings Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetUniformGridChild
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UWidget*                    Widget                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Column                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Row                                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWidget*                          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWidget* UUINavBlueprintFunctionLibrary::GetUniformGridChild(const class UWidget* Widget, const int32 Column, const int32 Row)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetUniformGridChild");

	Params::UINavBlueprintFunctionLibrary_GetUniformGridChild Parms{};

	Parms.Widget = Widget;
	Parms.Column = Column;
	Parms.Row = Row;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.GetValidUINavComponentInWidget
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UPanelWidget*               Widget                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavComponent* UUINavBlueprintFunctionLibrary::GetValidUINavComponentInWidget(const class UPanelWidget* Widget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "GetValidUINavComponentInWidget");

	Params::UINavBlueprintFunctionLibrary_GetValidUINavComponentInWidget Parms{};

	Parms.Widget = Widget;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.IsGamepadConnected
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavBlueprintFunctionLibrary::IsGamepadConnected()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "IsGamepadConnected");

	Params::UINavBlueprintFunctionLibrary_IsGamepadConnected Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.IsKeyInCategory
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Category                                               (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavBlueprintFunctionLibrary::IsKeyInCategory(const struct FKey& Key, const class FString& Category)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "IsKeyInCategory");

	Params::UINavBlueprintFunctionLibrary_IsKeyInCategory Parms{};

	Parms.Key = std::move(Key);
	Parms.Category = std::move(Category);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.IsUINavInputAction
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UInputAction*               InputAction                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavBlueprintFunctionLibrary::IsUINavInputAction(const class UInputAction* InputAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "IsUINavInputAction");

	Params::UINavBlueprintFunctionLibrary_IsUINavInputAction Parms{};

	Parms.InputAction = InputAction;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.IsVRKey
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavBlueprintFunctionLibrary::IsVRKey(const struct FKey& Key)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "IsVRKey");

	Params::UINavBlueprintFunctionLibrary_IsVRKey Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.ResetInputSettings
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                PC                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavBlueprintFunctionLibrary::ResetInputSettings(class APlayerController* PC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "ResetInputSettings");

	Params::UINavBlueprintFunctionLibrary_ResetInputSettings Parms{};

	Parms.PC = PC;

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

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

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.RespectsRestriction
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKey&                      CompareKey                                             (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputRestriction                 Restriction                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavBlueprintFunctionLibrary::RespectsRestriction(const struct FKey& CompareKey, const EInputRestriction Restriction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "RespectsRestriction");

	Params::UINavBlueprintFunctionLibrary_RespectsRestriction Parms{};

	Parms.CompareKey = std::move(CompareKey);
	Parms.Restriction = Restriction;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.SetPostProcessSettings
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Variable                                               (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Value                                                  (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavBlueprintFunctionLibrary::SetPostProcessSettings(const class FString& Variable, const class FString& Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "SetPostProcessSettings");

	Params::UINavBlueprintFunctionLibrary_SetPostProcessSettings Parms{};

	Parms.Variable = std::move(Variable);
	Parms.Value = std::move(Value);

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

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

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavBlueprintFunctionLibrary.SetSoundClassVolume
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USoundClass*                      TargetClass                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             NewVolume                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavBlueprintFunctionLibrary::SetSoundClassVolume(class USoundClass* TargetClass, const float NewVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("UINavBlueprintFunctionLibrary", "SetSoundClassVolume");

	Params::UINavBlueprintFunctionLibrary_SetSoundClassVolume Parms{};

	Parms.TargetClass = TargetClass;
	Parms.NewVolume = NewVolume;

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

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

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.OnButtonClicked
// (Final, Native, Public)

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

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

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.OnButtonHovered
// (Final, Native, Public)

void UUINavComponent::OnButtonHovered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "OnButtonHovered");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.OnButtonPressed
// (Final, Native, Public)

void UUINavComponent::OnButtonPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "OnButtonPressed");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.OnButtonReleased
// (Final, Native, Public)

void UUINavComponent::OnButtonReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "OnButtonReleased");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.OnButtonUnhovered
// (Final, Native, Public)

void UUINavComponent::OnButtonUnhovered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "OnButtonUnhovered");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.OnNavigatedFrom
// (Native, Event, Public, BlueprintEvent)

void UUINavComponent::OnNavigatedFrom()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "OnNavigatedFrom");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.OnNavigatedTo
// (Native, Event, Public, BlueprintEvent)

void UUINavComponent::OnNavigatedTo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "OnNavigatedTo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.SetText
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      Text                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UUINavComponent::SetText(const class FText& Text)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "SetText");

	Params::UINavComponent_SetText Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.SwitchButtonStyle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EButtonStyle                      NewStyle                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bRevertStyle                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavComponent::SwitchButtonStyle(const EButtonStyle NewStyle, const bool bRevertStyle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "SwitchButtonStyle");

	Params::UINavComponent_SwitchButtonStyle Parms{};

	Parms.NewStyle = NewStyle;
	Parms.bRevertStyle = bRevertStyle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.SwitchTextColorTo
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavComponent::SwitchTextColorTo(const struct FLinearColor& Color)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "SwitchTextColorTo");

	Params::UINavComponent_SwitchTextColorTo Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.SwitchTextColorToDefault
// (Final, Native, Public, BlueprintCallable)

void UUINavComponent::SwitchTextColorToDefault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "SwitchTextColorToDefault");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.SwitchTextColorToNavigated
// (Final, Native, Public, BlueprintCallable)

void UUINavComponent::SwitchTextColorToNavigated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "SwitchTextColorToNavigated");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavComponent.CanBeNavigated
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavComponent::CanBeNavigated() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "CanBeNavigated");

	Params::UINavComponent_CanBeNavigated Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavComponent.GetParentScrollBox
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UScrollBox*                       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UScrollBox* UUINavComponent::GetParentScrollBox() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "GetParentScrollBox");

	Params::UINavComponent_GetParentScrollBox Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavComponent.IsBeingNavigated
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavComponent::IsBeingNavigated() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponent", "IsBeingNavigated");

	Params::UINavComponent_IsBeingNavigated Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavHorizontalComponent.NavigateLeft
// (Native, Public, BlueprintCallable)

void UUINavHorizontalComponent::NavigateLeft()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavHorizontalComponent", "NavigateLeft");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavHorizontalComponent.NavigateRight
// (Native, Public, BlueprintCallable)

void UUINavHorizontalComponent::NavigateRight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavHorizontalComponent", "NavigateRight");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavHorizontalComponent.OnNavigateLeft
// (Native, Event, Public, BlueprintEvent)

void UUINavHorizontalComponent::OnNavigateLeft()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavHorizontalComponent", "OnNavigateLeft");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavHorizontalComponent.OnNavigateRight
// (Native, Event, Public, BlueprintEvent)

void UUINavHorizontalComponent::OnNavigateRight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavHorizontalComponent", "OnNavigateRight");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavHorizontalComponent.OnUpdated
// (Native, Event, Public, BlueprintEvent)

void UUINavHorizontalComponent::OnUpdated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavHorizontalComponent", "OnUpdated");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavHorizontalComponent.SetOptionIndex
// (Native, Public, BlueprintCallable)
// Parameters:
// int32                                   NewIndex                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavHorizontalComponent::SetOptionIndex(int32 NewIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavHorizontalComponent", "SetOptionIndex");

	Params::UINavHorizontalComponent_SetOptionIndex Parms{};

	Parms.NewIndex = NewIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavHorizontalComponent.Update
// (Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bNotify                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavHorizontalComponent::Update(const bool bNotify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavHorizontalComponent", "Update");

	Params::UINavHorizontalComponent_Update Parms{};

	Parms.bNotify = bNotify;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavHorizontalComponent.GetMaxOptionIndex
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UUINavHorizontalComponent::GetMaxOptionIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavHorizontalComponent", "GetMaxOptionIndex");

	Params::UINavHorizontalComponent_GetMaxOptionIndex Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

int32 UUINavComponentBox::GetCurrentNumber() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavComponentBox", "GetCurrentNumber");

	Params::UINavComponentBox_GetCurrentNumber Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavInputBox.InputComponent1Clicked
// (Final, Native, Protected)

void UUINavInputBox::InputComponent1Clicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputBox", "InputComponent1Clicked");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputBox.InputComponent2Clicked
// (Final, Native, Protected)

void UUINavInputBox::InputComponent2Clicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputBox", "InputComponent2Clicked");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputBox.InputComponent3Clicked
// (Final, Native, Protected)

void UUINavInputBox::InputComponent3Clicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputBox", "InputComponent3Clicked");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputContainer.ForceUpdateInputBoxes
// (Final, Native, Public, BlueprintCallable)

void UUINavInputContainer::ForceUpdateInputBoxes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "ForceUpdateInputBoxes");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputContainer.OnAddInputBox
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UUINavInputBox*                   NewInputBox                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavInputContainer::OnAddInputBox(class UUINavInputBox* NewInputBox)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "OnAddInputBox");

	Params::UINavInputContainer_OnAddInputBox Parms{};

	Parms.NewInputBox = NewInputBox;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputContainer.OnInputTypeChanged
// (Final, Native, Public)
// Parameters:
// const EInputType                        InputType                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavInputContainer::OnInputTypeChanged(const EInputType InputType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "OnInputTypeChanged");

	Params::UINavInputContainer_OnInputTypeChanged Parms{};

	Parms.InputType = InputType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputContainer.OnKeyRebinded
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class FName                             InputName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      OldKey                                                 (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      NewKey                                                 (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavInputContainer::OnKeyRebinded(class FName InputName, const struct FKey& OldKey, const struct FKey& NewKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "OnKeyRebinded");

	Params::UINavInputContainer_OnKeyRebinded Parms{};

	Parms.InputName = InputName;
	Parms.OldKey = std::move(OldKey);
	Parms.NewKey = std::move(NewKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputContainer.OnRebindCancelled
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// ERevertRebindReason                     RevertReason                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      PressedKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavInputContainer::OnRebindCancelled(ERevertRebindReason RevertReason, const struct FKey& PressedKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "OnRebindCancelled");

	Params::UINavInputContainer_OnRebindCancelled Parms{};

	Parms.RevertReason = RevertReason;
	Parms.PressedKey = std::move(PressedKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputContainer.ResetKeyMappings
// (Final, Native, Public, BlueprintCallable)

void UUINavInputContainer::ResetKeyMappings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "ResetKeyMappings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputContainer.RespectsRestriction
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKey&                      CompareKey                                             (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavInputContainer::RespectsRestriction(const struct FKey& CompareKey, const int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "RespectsRestriction");

	Params::UINavInputContainer_RespectsRestriction Parms{};

	Parms.CompareKey = std::move(CompareKey);
	Parms.Index_0 = Index_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavInputContainer.SwapKeysDecided
// (Final, Native, Public)
// Parameters:
// const class UPromptDataBase*            PromptData                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavInputContainer::SwapKeysDecided(const class UPromptDataBase* PromptData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "SwapKeysDecided");

	Params::UINavInputContainer_SwapKeysDecided Parms{};

	Parms.PromptData = PromptData;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputContainer.CanUseKey
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UUINavInputBox*                   InputBox                                               (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      CompareKey                                             (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bIsHold                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutCollidingActionIndex                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutCollidingKeyIndex                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavInputContainer::CanUseKey(class UUINavInputBox* InputBox, const struct FKey& CompareKey, const bool bIsHold, int32* OutCollidingActionIndex, int32* OutCollidingKeyIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "CanUseKey");

	Params::UINavInputContainer_CanUseKey Parms{};

	Parms.InputBox = InputBox;
	Parms.CompareKey = std::move(CompareKey);
	Parms.bIsHold = bIsHold;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function UINavigation.UINavInputContainer.GetInputBoxAtIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavInputBox*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavInputBox* UUINavInputContainer::GetInputBoxAtIndex(const int32 Index_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputContainer", "GetInputBoxAtIndex");

	Params::UINavInputContainer_GetInputBoxAtIndex Parms{};

	Parms.Index_0 = Index_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavInputDisplay.SetIconSize
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 NewSize                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavInputDisplay::SetIconSize(const struct FVector2D& NewSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputDisplay", "SetIconSize");

	Params::UINavInputDisplay_SetIconSize Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputDisplay.SetInputAction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UInputAction*                     NewAction                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputAxis                        NewAxis                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EAxisType                         NewScale                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavInputDisplay::SetInputAction(class UInputAction* NewAction, const EInputAxis NewAxis, const EAxisType NewScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputDisplay", "SetInputAction");

	Params::UINavInputDisplay_SetInputAction Parms{};

	Parms.NewAction = NewAction;
	Parms.NewAxis = NewAxis;
	Parms.NewScale = NewScale;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavInputDisplay.UpdateInputVisuals
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UUINavInputDisplay::UpdateInputVisuals()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavInputDisplay", "UpdateInputVisuals");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavOptionBox.GetCurrentString
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UUINavOptionBox::GetCurrentString() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavOptionBox", "GetCurrentString");

	Params::UINavOptionBox_GetCurrentString Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.AddInputContext
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UInputMappingContext*       Context                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Priority                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::AddInputContext(const class UInputMappingContext* Context, const int32 Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "AddInputContext");

	Params::UINavPCComponent_AddInputContext Parms{};

	Parms.Context = Context;
	Parms.Priority = Priority;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.ForceUpdateAllInputDisplays
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bOnlyTopLevel                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::ForceUpdateAllInputDisplays(const bool bOnlyTopLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "ForceUpdateAllInputDisplays");

	Params::UINavPCComponent_ForceUpdateAllInputDisplays Parms{};

	Parms.bOnlyTopLevel = bOnlyTopLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.GetEnhancedInputKeys
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FKey>*                    OutKeys                                                (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UUINavPCComponent::GetEnhancedInputKeys(const class UInputAction* Action, TArray<struct FKey>* OutKeys)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetEnhancedInputKeys");

	Params::UINavPCComponent_GetEnhancedInputKeys Parms{};

	Parms.Action = Action;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function UINavigation.UINavPCComponent.GoToBuiltWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUINavWidget*                     NewWidget                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bRemoveParent                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDestroyParent                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ZOrder                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavWidget* UUINavPCComponent::GoToBuiltWidget(class UUINavWidget* NewWidget, const bool bRemoveParent, const bool bDestroyParent, const int32 ZOrder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GoToBuiltWidget");

	Params::UINavPCComponent_GoToBuiltWidget Parms{};

	Parms.NewWidget = NewWidget;
	Parms.bRemoveParent = bRemoveParent;
	Parms.bDestroyParent = bDestroyParent;
	Parms.ZOrder = ZOrder;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GoToPromptWidget
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TSubclassOf<class UUINavPromptWidget>   NewWidgetClass                                         (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(const class UPromptDataBase* PromptData)>&Event                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      title                                                  (ConstParm, Parm, NativeAccessSpecifierPublic)
// const class FText&                      Message                                                (ConstParm, Parm, NativeAccessSpecifierPublic)
// const bool                              bRemoveParent                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ZOrder                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavWidget* UUINavPCComponent::GoToPromptWidget(TSubclassOf<class UUINavPromptWidget> NewWidgetClass, const TDelegate<void(const class UPromptDataBase* PromptData)>& Event, const class FText& title, const class FText& Message, const bool bRemoveParent, const int32 ZOrder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GoToPromptWidget");

	Params::UINavPCComponent_GoToPromptWidget Parms{};

	Parms.NewWidgetClass = NewWidgetClass;
	Parms.Event = Event;
	Parms.title = std::move(title);
	Parms.Message = std::move(Message);
	Parms.bRemoveParent = bRemoveParent;
	Parms.ZOrder = ZOrder;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GoToWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UUINavWidget>         NewWidgetClass                                         (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bRemoveParent                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDestroyParent                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ZOrder                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavWidget* UUINavPCComponent::GoToWidget(TSubclassOf<class UUINavWidget> NewWidgetClass, const bool bRemoveParent, const bool bDestroyParent, const int32 ZOrder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GoToWidget");

	Params::UINavPCComponent_GoToWidget Parms{};

	Parms.NewWidgetClass = NewWidgetClass;
	Parms.bRemoveParent = bRemoveParent;
	Parms.bDestroyParent = bDestroyParent;
	Parms.ZOrder = ZOrder;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.InputKey
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputEvent                       Event                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Delta                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::InputKey(const struct FKey& Key, const EInputEvent Event, const float Delta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "InputKey");

	Params::UINavPCComponent_InputKey Parms{};

	Parms.Key = std::move(Key);
	Parms.Event = Event;
	Parms.Delta = Delta;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.NavigateInDirection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EUINavigation                     Direction                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             UserIndex                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::NavigateInDirection(const EUINavigation Direction, const int32 UserIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "NavigateInDirection");

	Params::UINavPCComponent_NavigateInDirection Parms{};

	Parms.Direction = Direction;
	Parms.UserIndex = UserIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.NotifyNavigatedTo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUINavWidget*                     NavigatedWidget                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::NotifyNavigatedTo(class UUINavWidget* NavigatedWidget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "NotifyNavigatedTo");

	Params::UINavPCComponent_NotifyNavigatedTo Parms{};

	Parms.NavigatedWidget = NavigatedWidget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.RefreshNavigationKeys
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::RefreshNavigationKeys()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "RefreshNavigationKeys");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.RemoveInputContext
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UInputMappingContext*       Context                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::RemoveInputContext(const class UInputMappingContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "RemoveInputContext");

	Params::UINavPCComponent_RemoveInputContext Parms{};

	Parms.Context = Context;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SetActiveWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUINavWidget*                     NewActiveWidget                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::SetActiveWidget(class UUINavWidget* NewActiveWidget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SetActiveWidget");

	Params::UINavPCComponent_SetActiveWidget Parms{};

	Parms.NewActiveWidget = NewActiveWidget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SetAllowAllMenuInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bAllowInput                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::SetAllowAllMenuInput(const bool bAllowInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SetAllowAllMenuInput");

	Params::UINavPCComponent_SetAllowAllMenuInput Parms{};

	Parms.bAllowInput = bAllowInput;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SetAllowDirectionalInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bAllowInput                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::SetAllowDirectionalInput(const bool bAllowInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SetAllowDirectionalInput");

	Params::UINavPCComponent_SetAllowDirectionalInput Parms{};

	Parms.bAllowInput = bAllowInput;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SetAllowReturnInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bAllowInput                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::SetAllowReturnInput(const bool bAllowInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SetAllowReturnInput");

	Params::UINavPCComponent_SetAllowReturnInput Parms{};

	Parms.bAllowInput = bAllowInput;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SetAllowSectionInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bAllowInput                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::SetAllowSectionInput(const bool bAllowInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SetAllowSectionInput");

	Params::UINavPCComponent_SetAllowSectionInput Parms{};

	Parms.bAllowInput = bAllowInput;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SetAllowSelectInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bAllowInput                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::SetAllowSelectInput(const bool bAllowInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SetAllowSelectInput");

	Params::UINavPCComponent_SetAllowSelectInput Parms{};

	Parms.bAllowInput = bAllowInput;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SetGamepadInputDataTables
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDataTable*                       NewKeyIconTable                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UDataTable*                       NewKeyNameTable                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bUpdateInputDisplays                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::SetGamepadInputDataTables(class UDataTable* NewKeyIconTable, class UDataTable* NewKeyNameTable, const bool bUpdateInputDisplays)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SetGamepadInputDataTables");

	Params::UINavPCComponent_SetGamepadInputDataTables Parms{};

	Parms.NewKeyIconTable = NewKeyIconTable;
	Parms.NewKeyNameTable = NewKeyNameTable;
	Parms.bUpdateInputDisplays = bUpdateInputDisplays;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SetKeyboardInputDataTables
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDataTable*                       NewKeyIconTable                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UDataTable*                       NewKeyNameTable                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bUpdateInputDisplays                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::SetKeyboardInputDataTables(class UDataTable* NewKeyIconTable, class UDataTable* NewKeyNameTable, const bool bUpdateInputDisplays)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SetKeyboardInputDataTables");

	Params::UINavPCComponent_SetKeyboardInputDataTables Parms{};

	Parms.NewKeyIconTable = NewKeyIconTable;
	Parms.NewKeyNameTable = NewKeyNameTable;
	Parms.bUpdateInputDisplays = bUpdateInputDisplays;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SetShowMouseCursor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bShowMouse                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavPCComponent::SetShowMouseCursor(const bool bShowMouse)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SetShowMouseCursor");

	Params::UINavPCComponent_SetShowMouseCursor Parms{};

	Parms.bShowMouse = bShowMouse;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SimulateMouseClick
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::SimulateMouseClick()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SimulateMouseClick");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SimulateMousePress
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::SimulateMousePress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SimulateMousePress");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SimulateMouseRelease
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::SimulateMouseRelease()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SimulateMouseRelease");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SimulateReturn
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::SimulateReturn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SimulateReturn");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SimulateSelect
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::SimulateSelect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SimulateSelect");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SimulateStartReturn
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::SimulateStartReturn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SimulateStartReturn");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SimulateStartSelect
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::SimulateStartSelect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SimulateStartSelect");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SimulateStopReturn
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::SimulateStopReturn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SimulateStopReturn");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.SimulateStopSelect
// (Final, Native, Public, BlueprintCallable)

void UUINavPCComponent::SimulateStopSelect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "SimulateStopSelect");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCComponent.AllowsAllMenuInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::AllowsAllMenuInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "AllowsAllMenuInput");

	Params::UINavPCComponent_AllowsAllMenuInput Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.AllowsDirectionalInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::AllowsDirectionalInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "AllowsDirectionalInput");

	Params::UINavPCComponent_AllowsDirectionalInput Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.AllowsReturnInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::AllowsReturnInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "AllowsReturnInput");

	Params::UINavPCComponent_AllowsReturnInput Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.AllowsSectionInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::AllowsSectionInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "AllowsSectionInput");

	Params::UINavPCComponent_AllowsSectionInput Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.AllowsSelectInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::AllowsSelectInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "AllowsSelectInput");

	Params::UINavPCComponent_AllowsSelectInput Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetActiveSubWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UUINavWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavWidget* UUINavPCComponent::GetActiveSubWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetActiveSubWidget");

	Params::UINavPCComponent_GetActiveSubWidget Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetActiveWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UUINavWidget*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUINavWidget* UUINavPCComponent::GetActiveWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetActiveWidget");

	Params::UINavPCComponent_GetActiveWidget Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetAxis1DFromAxis2D
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputAxis                        Axis                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FKey UUINavPCComponent::GetAxis1DFromAxis2D(const struct FKey& Key, const EInputAxis Axis) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetAxis1DFromAxis2D");

	Params::UINavPCComponent_GetAxis1DFromAxis2D Parms{};

	Parms.Key = std::move(Key);
	Parms.Axis = Axis;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetAxis2DFromAxis1D
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FKey UUINavPCComponent::GetAxis2DFromAxis1D(const struct FKey& Key) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetAxis2DFromAxis1D");

	Params::UINavPCComponent_GetAxis2DFromAxis1D Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetAxisFromKey
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FKey UUINavPCComponent::GetAxisFromKey(const struct FKey& Key) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetAxisFromKey");

	Params::UINavPCComponent_GetAxisFromKey Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetAxisFromScaledKey
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bInclude1DAxis                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   OutbPositive                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FKey UUINavPCComponent::GetAxisFromScaledKey(const struct FKey& Key, const bool bInclude1DAxis, bool* OutbPositive) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetAxisFromScaledKey");

	Params::UINavPCComponent_GetAxisFromScaledKey Parms{};

	Parms.Key = std::move(Key);
	Parms.bInclude1DAxis = bInclude1DAxis;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetCurrentInputType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInputType                              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInputType UUINavPCComponent::GetCurrentInputType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetCurrentInputType");

	Params::UINavPCComponent_GetCurrentInputType Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetCurrentPlatformData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPlatformConfigData        ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FPlatformConfigData UUINavPCComponent::GetCurrentPlatformData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetCurrentPlatformData");

	Params::UINavPCComponent_GetCurrentPlatformData Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetEnhancedInputComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEnhancedInputComponent*          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEnhancedInputComponent* UUINavPCComponent::GetEnhancedInputComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetEnhancedInputComponent");

	Params::UINavPCComponent_GetEnhancedInputComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetEnhancedInputIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputAxis                        Axis                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EAxisType                         Scale                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputRestriction                 InputRestriction                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UUINavPCComponent::GetEnhancedInputIcon(const class UInputAction* Action, const EInputAxis Axis, const EAxisType Scale, const EInputRestriction InputRestriction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetEnhancedInputIcon");

	Params::UINavPCComponent_GetEnhancedInputIcon Parms{};

	Parms.Action = Action;
	Parms.Axis = Axis;
	Parms.Scale = Scale;
	Parms.InputRestriction = InputRestriction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetEnhancedInputKey
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputAxis                        Axis                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EAxisType                         Scale                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputRestriction                 InputRestriction                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UUINavPCComponent::GetEnhancedInputKey(const class UInputAction* Action, const EInputAxis Axis, const EAxisType Scale, const EInputRestriction InputRestriction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetEnhancedInputKey");

	Params::UINavPCComponent_GetEnhancedInputKey Parms{};

	Parms.Action = Action;
	Parms.Axis = Axis;
	Parms.Scale = Scale;
	Parms.InputRestriction = InputRestriction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetEnhancedInputText
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputAxis                        Axis                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EAxisType                         Scale                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputRestriction                 InputRestriction                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UUINavPCComponent::GetEnhancedInputText(const class UInputAction* Action, const EInputAxis Axis, const EAxisType Scale, const EInputRestriction InputRestriction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetEnhancedInputText");

	Params::UINavPCComponent_GetEnhancedInputText Parms{};

	Parms.Action = Action;
	Parms.Axis = Axis;
	Parms.Scale = Scale;
	Parms.InputRestriction = InputRestriction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetInputMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInputMode                              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInputMode UUINavPCComponent::GetInputMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetInputMode");

	Params::UINavPCComponent_GetInputMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetKeyFromAxis
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPositive                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputAxis                        Axis                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FKey UUINavPCComponent::GetKeyFromAxis(const struct FKey& Key, bool bPositive, const EInputAxis Axis) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetKeyFromAxis");

	Params::UINavPCComponent_GetKeyFromAxis Parms{};

	Parms.Key = std::move(Key);
	Parms.bPositive = bPositive;
	Parms.Axis = Axis;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetKeyIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UUINavPCComponent::GetKeyIcon(const struct FKey& Key) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetKeyIcon");

	Params::UINavPCComponent_GetKeyIcon Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetKeyText
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UUINavPCComponent::GetKeyText(const struct FKey& Key) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetKeyText");

	Params::UINavPCComponent_GetKeyText Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetOppositeAxis2DAxis
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FKey UUINavPCComponent::GetOppositeAxis2DAxis(const struct FKey& Key) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetOppositeAxis2DAxis");

	Params::UINavPCComponent_GetOppositeAxis2DAxis Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetOppositeAxisKey
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bOutIsPositive                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FKey UUINavPCComponent::GetOppositeAxisKey(const struct FKey& Key, bool* bOutIsPositive) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetOppositeAxisKey");

	Params::UINavPCComponent_GetOppositeAxisKey Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetPC
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APlayerController*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APlayerController* UUINavPCComponent::GetPC() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetPC");

	Params::UINavPCComponent_GetPC Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetSoftEnhancedInputIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputAxis                        Axis                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EAxisType                         Scale                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputRestriction                 InputRestriction                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class UTexture2D>        ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class UTexture2D> UUINavPCComponent::GetSoftEnhancedInputIcon(const class UInputAction* Action, const EInputAxis Axis, const EAxisType Scale, const EInputRestriction InputRestriction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetSoftEnhancedInputIcon");

	Params::UINavPCComponent_GetSoftEnhancedInputIcon Parms{};

	Parms.Action = Action;
	Parms.Axis = Axis;
	Parms.Scale = Scale;
	Parms.InputRestriction = InputRestriction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetSoftKeyIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class UTexture2D>        ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class UTexture2D> UUINavPCComponent::GetSoftKeyIcon(const struct FKey& Key) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetSoftKeyIcon");

	Params::UINavPCComponent_GetSoftKeyIcon Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetThumbstickDelta
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector2D                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector2D UUINavPCComponent::GetThumbstickDelta() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetThumbstickDelta");

	Params::UINavPCComponent_GetThumbstickDelta Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.GetUINavInputContext
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UUINavWidget*               UINavWidget                                            (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInputMappingContext*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInputMappingContext* UUINavPCComponent::GetUINavInputContext(const class UUINavWidget* UINavWidget) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "GetUINavInputContext");

	Params::UINavPCComponent_GetUINavInputContext Parms{};

	Parms.UINavWidget = UINavWidget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.HidingMouseCursor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::HidingMouseCursor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "HidingMouseCursor");

	Params::UINavPCComponent_HidingMouseCursor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.IsAxis
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::IsAxis(const struct FKey& Key) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "IsAxis");

	Params::UINavPCComponent_IsAxis Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.IsAxis2D
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::IsAxis2D(const struct FKey& Key) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "IsAxis2D");

	Params::UINavPCComponent_IsAxis2D Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.IsMovingThumbstick
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::IsMovingThumbstick() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "IsMovingThumbstick");

	Params::UINavPCComponent_IsMovingThumbstick Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.IsUsingGamepad
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::IsUsingGamepad() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "IsUsingGamepad");

	Params::UINavPCComponent_IsUsingGamepad Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.IsUsingKeyboard
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::IsUsingKeyboard() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "IsUsingKeyboard");

	Params::UINavPCComponent_IsUsingKeyboard Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.IsUsingMouse
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::IsUsingMouse() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "IsUsingMouse");

	Params::UINavPCComponent_IsUsingMouse Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.IsWaitingForInputCooldown
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::IsWaitingForInputCooldown() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "IsWaitingForInputCooldown");

	Params::UINavPCComponent_IsWaitingForInputCooldown Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.IsWidgetActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UUINavWidget*               UINavWidget                                            (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::IsWidgetActive(const class UUINavWidget* UINavWidget) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "IsWidgetActive");

	Params::UINavPCComponent_IsWidgetActive Parms{};

	Parms.UINavWidget = UINavWidget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCComponent.IsWidgetChild
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UUINavWidget*               ParentWidget                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UUINavWidget*               ChildWidget                                            (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUINavPCComponent::IsWidgetChild(const class UUINavWidget* ParentWidget, const class UUINavWidget* ChildWidget) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavPCComponent", "IsWidgetChild");

	Params::UINavPCComponent_IsWidgetChild Parms{};

	Parms.ParentWidget = ParentWidget;
	Parms.ChildWidget = ChildWidget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavPCReceiver.OnActiveWidgetChanged
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UUINavWidget*                     OldActiveWidget                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUINavWidget*                     NewActiveWidget                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IUINavPCReceiver::OnActiveWidgetChanged(class UUINavWidget* OldActiveWidget, class UUINavWidget* NewActiveWidget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnActiveWidgetChanged");

	Params::UINavPCReceiver_OnActiveWidgetChanged Parms{};

	Parms.OldActiveWidget = OldActiveWidget;
	Parms.NewActiveWidget = NewActiveWidget;

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

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

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnControllerConnectionChanged
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bConnected                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IUINavPCReceiver::OnControllerConnectionChanged(bool bConnected, int32 UserId, int32 UserIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnControllerConnectionChanged");

	Params::UINavPCReceiver_OnControllerConnectionChanged Parms{};

	Parms.bConnected = bConnected;
	Parms.UserId = UserId;
	Parms.UserIndex = UserIndex;

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

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

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnInputChanged
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EInputType                              From                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputType                              To                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IUINavPCReceiver::OnInputChanged(EInputType From, EInputType To)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnInputChanged");

	Params::UINavPCReceiver_OnInputChanged Parms{};

	Parms.From = From;
	Parms.To = To;

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

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

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnNavigated
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EUINavigation                           NavigationDirection                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IUINavPCReceiver::OnNavigated(EUINavigation NavigationDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnNavigated");

	Params::UINavPCReceiver_OnNavigated Parms{};

	Parms.NavigationDirection = NavigationDirection;

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

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

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnNext
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IUINavPCReceiver::OnNext()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnNext");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnPrevious
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IUINavPCReceiver::OnPrevious()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnPrevious");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnReturn
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IUINavPCReceiver::OnReturn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnReturn");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnRootWidgetAdded
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IUINavPCReceiver::OnRootWidgetAdded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnRootWidgetAdded");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnRootWidgetRemoved
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IUINavPCReceiver::OnRootWidgetRemoved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnRootWidgetRemoved");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnSelect
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IUINavPCReceiver::OnSelect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnSelect");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavPCReceiver.OnThumbstickCursorInput
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector2D&                 ThumbstickDelta                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IUINavPCReceiver::OnThumbstickCursorInput(const struct FVector2D& ThumbstickDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("UINavPCReceiver", "OnThumbstickCursorInput");

	Params::UINavPCReceiver_OnThumbstickCursorInput Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.HandleOnSliderMouseCaptureBegin
// (Final, Native, Protected)

void UUINavSlider::HandleOnSliderMouseCaptureBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "HandleOnSliderMouseCaptureBegin");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.HandleOnSliderMouseCaptureEnd
// (Final, Native, Protected)

void UUINavSlider::HandleOnSliderMouseCaptureEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "HandleOnSliderMouseCaptureEnd");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.HandleOnSliderValueChanged
// (Final, Native, Protected)
// Parameters:
// const float                             InValue                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavSlider::HandleOnSliderValueChanged(const float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "HandleOnSliderValueChanged");

	Params::UINavSlider_HandleOnSliderValueChanged Parms{};

	Parms.InValue = InValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.HandleOnSpinBoxMouseCaptureBegin
// (Final, Native, Protected)

void UUINavSlider::HandleOnSpinBoxMouseCaptureBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "HandleOnSpinBoxMouseCaptureBegin");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.HandleOnSpinBoxValueChanged
// (Final, Native, Protected)
// Parameters:
// const float                             InValue                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavSlider::HandleOnSpinBoxValueChanged(const float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "HandleOnSpinBoxValueChanged");

	Params::UINavSlider_HandleOnSpinBoxValueChanged Parms{};

	Parms.InValue = InValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.HandleOnSpinBoxValueCommitted
// (Final, Native, Protected)
// Parameters:
// const float                             InValue                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ETextCommit                       CommitMethod                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavSlider::HandleOnSpinBoxValueCommitted(const float InValue, const ETextCommit CommitMethod)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "HandleOnSpinBoxValueCommitted");

	Params::UINavSlider_HandleOnSpinBoxValueCommitted Parms{};

	Parms.InValue = InValue;
	Parms.CommitMethod = CommitMethod;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.SetInterval
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const float                             NewInterval                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bNotifyUpdate                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavSlider::SetInterval(const float NewInterval, const bool bNotifyUpdate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "SetInterval");

	Params::UINavSlider_SetInterval Parms{};

	Parms.NewInterval = NewInterval;
	Parms.bNotifyUpdate = bNotifyUpdate;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.SetMaxDecimalDigits
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const int32                             DecimalDigits                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavSlider::SetMaxDecimalDigits(const int32 DecimalDigits)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "SetMaxDecimalDigits");

	Params::UINavSlider_SetMaxDecimalDigits Parms{};

	Parms.DecimalDigits = DecimalDigits;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.SetMaxValue
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const float                             NewValue                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bNotifyUpdate                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavSlider::SetMaxValue(const float NewValue, const bool bNotifyUpdate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "SetMaxValue");

	Params::UINavSlider_SetMaxValue Parms{};

	Parms.NewValue = NewValue;
	Parms.bNotifyUpdate = bNotifyUpdate;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.SetMinDecimalDigits
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const int32                             DecimalDigits                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavSlider::SetMinDecimalDigits(const int32 DecimalDigits)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "SetMinDecimalDigits");

	Params::UINavSlider_SetMinDecimalDigits Parms{};

	Parms.DecimalDigits = DecimalDigits;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.SetMinValue
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const float                             NewValue                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bNotifyUpdate                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavSlider::SetMinValue(const float NewValue, const bool bNotifyUpdate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "SetMinValue");

	Params::UINavSlider_SetMinValue Parms{};

	Parms.NewValue = NewValue;
	Parms.bNotifyUpdate = bNotifyUpdate;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.SetValueClamped
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             Value                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUINavSlider::SetValueClamped(const float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "SetValueClamped");

	Params::UINavSlider_SetValueClamped Parms{};

	Parms.Value = Value;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function UINavigation.UINavSlider.GetCurrentValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UUINavSlider::GetCurrentValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "GetCurrentValue");

	Params::UINavSlider_GetCurrentValue Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavSlider.GetSliderValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UUINavSlider::GetSliderValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSlider", "GetSliderValue");

	Params::UINavSlider_GetSliderValue Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function UINavigation.UINavSliderBox.GetSliderPercent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UUINavSliderBox::GetSliderPercent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UINavSliderBox", "GetSliderPercent");

	Params::UINavSliderBox_GetSliderPercent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


SDK_NAMESPACE_END
