#pragma once

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

// Package: EnhancedInput

#include "Basic.hpp"

#include "EnhancedInput_classes.hpp"
#include "EnhancedInput_parameters.hpp"


SDK_NAMESPACE_START

// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.ResetMappingToDefault
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FName                       InMappingName                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEnhancedPlayerMappableKeyProfile::ResetMappingToDefault(const class FName InMappingName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "ResetMappingToDefault");

	Params::EnhancedPlayerMappableKeyProfile_ResetMappingToDefault Parms{};

	Parms.InMappingName = InMappingName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.ResetToDefault
// (RequiredAPI, Native, Public, BlueprintCallable)

void UEnhancedPlayerMappableKeyProfile::ResetToDefault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "ResetToDefault");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.SetDisplayName
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      NewDisplayName                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UEnhancedPlayerMappableKeyProfile::SetDisplayName(const class FText& NewDisplayName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "SetDisplayName");

	Params::EnhancedPlayerMappableKeyProfile_SetDisplayName Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.DoesMappingPassQueryOptions
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPlayerKeyMapping&         PlayerMapping                                          (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPlayerMappableKeyQueryOptions&Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedPlayerMappableKeyProfile::DoesMappingPassQueryOptions(const struct FPlayerKeyMapping& PlayerMapping, const struct FPlayerMappableKeyQueryOptions& Options) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "DoesMappingPassQueryOptions");

	Params::EnhancedPlayerMappableKeyProfile_DoesMappingPassQueryOptions Parms{};

	Parms.PlayerMapping = std::move(PlayerMapping);
	Parms.Options = std::move(Options);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.DumpProfileToLog
// (RequiredAPI, Native, Public, BlueprintCallable, Const)

void UEnhancedPlayerMappableKeyProfile::DumpProfileToLog() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "DumpProfileToLog");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.GetMappedKeysInRow
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       MappingName                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FKey>*                    OutKeys                                                (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEnhancedPlayerMappableKeyProfile::GetMappedKeysInRow(const class FName MappingName, TArray<struct FKey>* OutKeys) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "GetMappedKeysInRow");

	Params::EnhancedPlayerMappableKeyProfile_GetMappedKeysInRow Parms{};

	Parms.MappingName = MappingName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.GetMappingNamesForKey
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      InKey                                                  (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FName>*                    OutMappingNames                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEnhancedPlayerMappableKeyProfile::GetMappingNamesForKey(const struct FKey& InKey, TArray<class FName>* OutMappingNames) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "GetMappingNamesForKey");

	Params::EnhancedPlayerMappableKeyProfile_GetMappingNamesForKey Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.GetPlayerMappingRows
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TMap<class FName, struct FKeyMappingRow>ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TMap<class FName, struct FKeyMappingRow> UEnhancedPlayerMappableKeyProfile::GetPlayerMappingRows() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "GetPlayerMappingRows");

	Params::EnhancedPlayerMappableKeyProfile_GetPlayerMappingRows Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.GetProfileDisplayName
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FText                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const class FText UEnhancedPlayerMappableKeyProfile::GetProfileDisplayName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "GetProfileDisplayName");

	Params::EnhancedPlayerMappableKeyProfile_GetProfileDisplayName Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.GetProfileIdString
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UEnhancedPlayerMappableKeyProfile::GetProfileIdString() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "GetProfileIdString");

	Params::EnhancedPlayerMappableKeyProfile_GetProfileIdString Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.K2_FindKeyMapping
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FPlayerKeyMapping*               OutKeyMapping                                          (Parm, OutParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMapPlayerKeyArgs&         InArgs                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UEnhancedPlayerMappableKeyProfile::K2_FindKeyMapping(struct FPlayerKeyMapping* OutKeyMapping, const struct FMapPlayerKeyArgs& InArgs) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "K2_FindKeyMapping");

	Params::EnhancedPlayerMappableKeyProfile_K2_FindKeyMapping Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.QueryPlayerMappedKeys
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPlayerMappableKeyQueryOptions&Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<struct FKey>*                    OutKeys                                                (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEnhancedPlayerMappableKeyProfile::QueryPlayerMappedKeys(const struct FPlayerMappableKeyQueryOptions& Options, TArray<struct FKey>* OutKeys) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "QueryPlayerMappedKeys");

	Params::EnhancedPlayerMappableKeyProfile_QueryPlayerMappedKeys Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedPlayerMappableKeyProfile.ToString
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UEnhancedPlayerMappableKeyProfile::ToString() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedPlayerMappableKeyProfile", "ToString");

	Params::EnhancedPlayerMappableKeyProfile_ToString Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.ApplySettings
// (RequiredAPI, Native, Public, BlueprintCallable)

void UEnhancedInputUserSettings::ApplySettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "ApplySettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputUserSettings.AsyncSaveSettings
// (RequiredAPI, Native, Public, BlueprintCallable)

void UEnhancedInputUserSettings::AsyncSaveSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "AsyncSaveSettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputUserSettings.CreateNewKeyProfile
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPlayerMappableKeyProfileCreationArgs&InArgs                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class UEnhancedPlayerMappableKeyProfile*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEnhancedPlayerMappableKeyProfile* UEnhancedInputUserSettings::CreateNewKeyProfile(const struct FPlayerMappableKeyProfileCreationArgs& InArgs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "CreateNewKeyProfile");

	Params::EnhancedInputUserSettings_CreateNewKeyProfile Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.MapPlayerKey
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FMapPlayerKeyArgs&         InArgs                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FGameplayTagContainer*           FailureReason                                          (Parm, OutParm, NativeAccessSpecifierPublic)

void UEnhancedInputUserSettings::MapPlayerKey(const struct FMapPlayerKeyArgs& InArgs, struct FGameplayTagContainer* FailureReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "MapPlayerKey");

	Params::EnhancedInputUserSettings_MapPlayerKey Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function EnhancedInput.EnhancedInputUserSettings.RegisterInputMappingContext
// (RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class UInputMappingContext*       IMC                                                    (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedInputUserSettings::RegisterInputMappingContext(const class UInputMappingContext* IMC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "RegisterInputMappingContext");

	Params::EnhancedInputUserSettings_RegisterInputMappingContext Parms{};

	Parms.IMC = IMC;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.RegisterInputMappingContexts
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSet<class UInputMappingContext*>&MappingContexts                                        (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedInputUserSettings::RegisterInputMappingContexts(const TSet<class UInputMappingContext*>& MappingContexts)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "RegisterInputMappingContexts");

	Params::EnhancedInputUserSettings_RegisterInputMappingContexts Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.ResetAllPlayerKeysInRow
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FMapPlayerKeyArgs&         InArgs                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FGameplayTagContainer*           FailureReason                                          (Parm, OutParm, NativeAccessSpecifierPublic)

void UEnhancedInputUserSettings::ResetAllPlayerKeysInRow(const struct FMapPlayerKeyArgs& InArgs, struct FGameplayTagContainer* FailureReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "ResetAllPlayerKeysInRow");

	Params::EnhancedInputUserSettings_ResetAllPlayerKeysInRow Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function EnhancedInput.EnhancedInputUserSettings.ResetKeyProfileIdToDefault
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ProfileId                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayTagContainer*           FailureReason                                          (Parm, OutParm, NativeAccessSpecifierPublic)

void UEnhancedInputUserSettings::ResetKeyProfileIdToDefault(const class FString& ProfileId, struct FGameplayTagContainer* FailureReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "ResetKeyProfileIdToDefault");

	Params::EnhancedInputUserSettings_ResetKeyProfileIdToDefault Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function EnhancedInput.EnhancedInputUserSettings.ResetKeyProfileToDefault
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              ProfileId                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayTagContainer*           FailureReason                                          (Parm, OutParm, NativeAccessSpecifierPublic)

void UEnhancedInputUserSettings::ResetKeyProfileToDefault(const struct FGameplayTag& ProfileId, struct FGameplayTagContainer* FailureReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "ResetKeyProfileToDefault");

	Params::EnhancedInputUserSettings_ResetKeyProfileToDefault Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function EnhancedInput.EnhancedInputUserSettings.SaveSettings
// (RequiredAPI, Native, Public, BlueprintCallable)

void UEnhancedInputUserSettings::SaveSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "SaveSettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputUserSettings.SetActiveKeyProfile
// (RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InProfileId                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedInputUserSettings::SetActiveKeyProfile(const class FString& InProfileId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "SetActiveKeyProfile");

	Params::EnhancedInputUserSettings_SetActiveKeyProfile Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.UnMapPlayerKey
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FMapPlayerKeyArgs&         InArgs                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FGameplayTagContainer*           FailureReason                                          (Parm, OutParm, NativeAccessSpecifierPublic)

void UEnhancedInputUserSettings::UnMapPlayerKey(const struct FMapPlayerKeyArgs& InArgs, struct FGameplayTagContainer* FailureReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "UnMapPlayerKey");

	Params::EnhancedInputUserSettings_UnMapPlayerKey Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function EnhancedInput.EnhancedInputUserSettings.UnregisterInputMappingContext
// (RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class UInputMappingContext*       IMC                                                    (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedInputUserSettings::UnregisterInputMappingContext(const class UInputMappingContext* IMC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "UnregisterInputMappingContext");

	Params::EnhancedInputUserSettings_UnregisterInputMappingContext Parms{};

	Parms.IMC = IMC;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.UnregisterInputMappingContexts
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSet<class UInputMappingContext*>&MappingContexts                                        (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedInputUserSettings::UnregisterInputMappingContexts(const TSet<class UInputMappingContext*>& MappingContexts)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "UnregisterInputMappingContexts");

	Params::EnhancedInputUserSettings_UnregisterInputMappingContexts Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.FindMappingsInRow
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       MappingName                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TSet<struct FPlayerKeyMapping>    ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TSet<struct FPlayerKeyMapping> UEnhancedInputUserSettings::FindMappingsInRow(const class FName MappingName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "FindMappingsInRow");

	Params::EnhancedInputUserSettings_FindMappingsInRow Parms{};

	Parms.MappingName = MappingName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.GetActiveKeyProfile
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEnhancedPlayerMappableKeyProfile*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEnhancedPlayerMappableKeyProfile* UEnhancedInputUserSettings::GetActiveKeyProfile() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "GetActiveKeyProfile");

	Params::EnhancedInputUserSettings_GetActiveKeyProfile Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.GetActiveKeyProfileId
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UEnhancedInputUserSettings::GetActiveKeyProfileId() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "GetActiveKeyProfileId");

	Params::EnhancedInputUserSettings_GetActiveKeyProfileId Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.GetKeyProfileWithId
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    ProfileId                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEnhancedPlayerMappableKeyProfile*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEnhancedPlayerMappableKeyProfile* UEnhancedInputUserSettings::GetKeyProfileWithId(const class FString& ProfileId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "GetKeyProfileWithId");

	Params::EnhancedInputUserSettings_GetKeyProfileWithId Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputUserSettings.IsMappingContextRegistered
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInputMappingContext*       IMC                                                    (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedInputUserSettings::IsMappingContextRegistered(const class UInputMappingContext* IMC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputUserSettings", "IsMappingContextRegistered");

	Params::EnhancedInputUserSettings_IsMappingContextRegistered Parms{};

	Parms.IMC = IMC;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputComponent.GetBoundActionValue
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FInputActionValue                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FInputActionValue UEnhancedInputComponent::GetBoundActionValue(const class UInputAction* Action) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputComponent", "GetBoundActionValue");

	Params::EnhancedInputComponent_GetBoundActionValue Parms{};

	Parms.Action = Action;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.BreakInputActionValue
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FInputActionValue&         InActionValue                                          (Parm, NoDestructor, NativeAccessSpecifierPublic)
// double*                                 X                                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double*                                 Y                                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double*                                 Z                                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputActionValueType*                  Type                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEnhancedInputLibrary::BreakInputActionValue(const struct FInputActionValue& InActionValue, double* X, double* Y, double* Z, EInputActionValueType* Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "BreakInputActionValue");

	Params::EnhancedInputLibrary_BreakInputActionValue Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

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

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

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

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


// Function EnhancedInput.EnhancedInputLibrary.Conv_InputActionValueToAxis1D
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FInputActionValue&         InValue                                                (Parm, NoDestructor, NativeAccessSpecifierPublic)
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

double UEnhancedInputLibrary::Conv_InputActionValueToAxis1D(const struct FInputActionValue& InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "Conv_InputActionValueToAxis1D");

	Params::EnhancedInputLibrary_Conv_InputActionValueToAxis1D Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.Conv_InputActionValueToAxis2D
// (Final, RequiredAPI, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FInputActionValue&         InValue                                                (Parm, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector2D                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector2D UEnhancedInputLibrary::Conv_InputActionValueToAxis2D(const struct FInputActionValue& InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "Conv_InputActionValueToAxis2D");

	Params::EnhancedInputLibrary_Conv_InputActionValueToAxis2D Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.Conv_InputActionValueToAxis3D
// (Final, RequiredAPI, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FInputActionValue&         ActionValue                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEnhancedInputLibrary::Conv_InputActionValueToAxis3D(const struct FInputActionValue& ActionValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "Conv_InputActionValueToAxis3D");

	Params::EnhancedInputLibrary_Conv_InputActionValueToAxis3D Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.Conv_InputActionValueToBool
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FInputActionValue&         InValue                                                (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedInputLibrary::Conv_InputActionValueToBool(const struct FInputActionValue& InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "Conv_InputActionValueToBool");

	Params::EnhancedInputLibrary_Conv_InputActionValueToBool Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.Conv_InputActionValueToString
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FInputActionValue&         ActionValue                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UEnhancedInputLibrary::Conv_InputActionValueToString(const struct FInputActionValue& ActionValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "Conv_InputActionValueToString");

	Params::EnhancedInputLibrary_Conv_InputActionValueToString Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.Conv_TriggerEventValueToString
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const ETriggerEvent                     TriggerEvent                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UEnhancedInputLibrary::Conv_TriggerEventValueToString(const ETriggerEvent TriggerEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "Conv_TriggerEventValueToString");

	Params::EnhancedInputLibrary_Conv_TriggerEventValueToString Parms{};

	Parms.TriggerEvent = TriggerEvent;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.FlushPlayerInput
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEnhancedInputLibrary::FlushPlayerInput(class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "FlushPlayerInput");

	Params::EnhancedInputLibrary_FlushPlayerInput Parms{};

	Parms.PlayerController = PlayerController;

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputLibrary.GetBoundActionValue
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FInputActionValue                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FInputActionValue UEnhancedInputLibrary::GetBoundActionValue(class AActor* Actor, const class UInputAction* Action)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "GetBoundActionValue");

	Params::EnhancedInputLibrary_GetBoundActionValue Parms{};

	Parms.Actor = Actor;
	Parms.Action = Action;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.GetMappingName
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FEnhancedActionKeyMapping& ActionKeyMapping                                       (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UEnhancedInputLibrary::GetMappingName(const struct FEnhancedActionKeyMapping& ActionKeyMapping)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "GetMappingName");

	Params::EnhancedInputLibrary_GetMappingName Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.GetPlayerMappableKeySettings
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FEnhancedActionKeyMapping& ActionKeyMapping                                       (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UPlayerMappableKeySettings*       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPlayerMappableKeySettings* UEnhancedInputLibrary::GetPlayerMappableKeySettings(const struct FEnhancedActionKeyMapping& ActionKeyMapping)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "GetPlayerMappableKeySettings");

	Params::EnhancedInputLibrary_GetPlayerMappableKeySettings Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.IsActionKeyMappingPlayerMappable
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FEnhancedActionKeyMapping& ActionKeyMapping                                       (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedInputLibrary::IsActionKeyMappingPlayerMappable(const struct FEnhancedActionKeyMapping& ActionKeyMapping)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "IsActionKeyMappingPlayerMappable");

	Params::EnhancedInputLibrary_IsActionKeyMappingPlayerMappable Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.MakeInputActionValueOfType
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// double                                  X                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double                                  Y                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double                                  Z                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputActionValueType             ValueType                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FInputActionValue                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FInputActionValue UEnhancedInputLibrary::MakeInputActionValueOfType(double X, double Y, double Z, const EInputActionValueType ValueType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "MakeInputActionValueOfType");

	Params::EnhancedInputLibrary_MakeInputActionValueOfType Parms{};

	Parms.X = X;
	Parms.Y = Y;
	Parms.Z = Z;
	Parms.ValueType = ValueType;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputLibrary.RequestRebuildControlMappingsUsingContext
// (Final, RequiredAPI, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UInputMappingContext*       Context                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceImmediately                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEnhancedInputLibrary::RequestRebuildControlMappingsUsingContext(const class UInputMappingContext* Context, bool bForceImmediately)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EnhancedInputLibrary", "RequestRebuildControlMappingsUsingContext");

	Params::EnhancedInputLibrary_RequestRebuildControlMappingsUsingContext Parms{};

	Parms.Context = Context;
	Parms.bForceImmediately = bForceImmediately;

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputPlatformData.GetContextRedirect
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UInputMappingContext*             InContext                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInputMappingContext*       ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UInputMappingContext* UEnhancedInputPlatformData::GetContextRedirect(class UInputMappingContext* InContext) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputPlatformData", "GetContextRedirect");

	Params::EnhancedInputPlatformData_GetContextRedirect Parms{};

	Parms.InContext = InContext;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.AddMappingContext
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UInputMappingContext*       MappingContext                                         (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FModifyContextOptions&     Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::AddMappingContext(const class UInputMappingContext* MappingContext, int32 Priority, const struct FModifyContextOptions& Options)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "AddMappingContext");

	Params::EnhancedInputSubsystemInterface_AddMappingContext Parms{};

	Parms.MappingContext = MappingContext;
	Parms.Priority = Priority;
	Parms.Options = std::move(Options);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.AddTagToInputMode
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TagToAdd                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FModifyContextOptions&     Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::AddTagToInputMode(const struct FGameplayTag& TagToAdd, const struct FModifyContextOptions& Options)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "AddTagToInputMode");

	Params::EnhancedInputSubsystemInterface_AddTagToInputMode Parms{};

	Parms.TagToAdd = std::move(TagToAdd);
	Parms.Options = std::move(Options);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.AppendTagsToInputMode
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     TagsToAdd                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FModifyContextOptions&     Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::AppendTagsToInputMode(const struct FGameplayTagContainer& TagsToAdd, const struct FModifyContextOptions& Options)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "AppendTagsToInputMode");

	Params::EnhancedInputSubsystemInterface_AppendTagsToInputMode Parms{};

	Parms.TagsToAdd = std::move(TagsToAdd);
	Parms.Options = std::move(Options);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.ClearAllMappings
// (RequiredAPI, BlueprintCosmetic, Native, Public, BlueprintCallable)

void IEnhancedInputSubsystemInterface::ClearAllMappings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "ClearAllMappings");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.InjectInputForAction
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputActionValue&         RawValue                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<class UInputModifier*>&    Modifiers                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class UInputTrigger*>&     Triggers                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::InjectInputForAction(const class UInputAction* Action, const struct FInputActionValue& RawValue, const TArray<class UInputModifier*>& Modifiers, const TArray<class UInputTrigger*>& Triggers)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "InjectInputForAction");

	Params::EnhancedInputSubsystemInterface_InjectInputForAction Parms{};

	Parms.Action = Action;
	Parms.RawValue = std::move(RawValue);
	Parms.Modifiers = std::move(Modifiers);
	Parms.Triggers = std::move(Triggers);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.InjectInputForPlayerMapping
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName                       MappingName                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputActionValue&         RawValue                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<class UInputModifier*>&    Modifiers                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class UInputTrigger*>&     Triggers                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::InjectInputForPlayerMapping(const class FName MappingName, const struct FInputActionValue& RawValue, const TArray<class UInputModifier*>& Modifiers, const TArray<class UInputTrigger*>& Triggers)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "InjectInputForPlayerMapping");

	Params::EnhancedInputSubsystemInterface_InjectInputForPlayerMapping Parms{};

	Parms.MappingName = MappingName;
	Parms.RawValue = std::move(RawValue);
	Parms.Modifiers = std::move(Modifiers);
	Parms.Triggers = std::move(Triggers);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.InjectInputVectorForAction
// (RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UInputModifier*>&    Modifiers                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class UInputTrigger*>&     Triggers                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::InjectInputVectorForAction(const class UInputAction* Action, const struct FVector& Value, const TArray<class UInputModifier*>& Modifiers, const TArray<class UInputTrigger*>& Triggers)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "InjectInputVectorForAction");

	Params::EnhancedInputSubsystemInterface_InjectInputVectorForAction Parms{};

	Parms.Action = Action;
	Parms.Value = std::move(Value);
	Parms.Modifiers = std::move(Modifiers);
	Parms.Triggers = std::move(Triggers);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.InjectInputVectorForPlayerMapping
// (RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class FName                       MappingName                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UInputModifier*>&    Modifiers                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class UInputTrigger*>&     Triggers                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::InjectInputVectorForPlayerMapping(const class FName MappingName, const struct FVector& Value, const TArray<class UInputModifier*>& Modifiers, const TArray<class UInputTrigger*>& Triggers)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "InjectInputVectorForPlayerMapping");

	Params::EnhancedInputSubsystemInterface_InjectInputVectorForPlayerMapping Parms{};

	Parms.MappingName = MappingName;
	Parms.Value = std::move(Value);
	Parms.Modifiers = std::move(Modifiers);
	Parms.Triggers = std::move(Triggers);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.OnUserKeyProfileChanged
// (RequiredAPI, Native, Protected)
// Parameters:
// const class UEnhancedPlayerMappableKeyProfile*InNewProfile                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::OnUserKeyProfileChanged(const class UEnhancedPlayerMappableKeyProfile* InNewProfile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "OnUserKeyProfileChanged");

	Params::EnhancedInputSubsystemInterface_OnUserKeyProfileChanged Parms{};

	Parms.InNewProfile = InNewProfile;

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.OnUserSettingsChanged
// (RequiredAPI, Native, Protected)
// Parameters:
// class UEnhancedInputUserSettings*       Settings                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::OnUserSettingsChanged(class UEnhancedInputUserSettings* Settings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "OnUserSettingsChanged");

	Params::EnhancedInputSubsystemInterface_OnUserSettingsChanged Parms{};

	Parms.Settings = Settings;

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.QueryMapKeyInActiveContextSet
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UInputMappingContext*       InputContext                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      Key                                                    (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FMappingQueryIssue>*      OutIssues                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// EMappingQueryIssue                      BlockingIssues                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMappingQueryResult                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EMappingQueryResult IEnhancedInputSubsystemInterface::QueryMapKeyInActiveContextSet(const class UInputMappingContext* InputContext, const class UInputAction* Action, const struct FKey& Key, TArray<struct FMappingQueryIssue>* OutIssues, EMappingQueryIssue BlockingIssues)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "QueryMapKeyInActiveContextSet");

	Params::EnhancedInputSubsystemInterface_QueryMapKeyInActiveContextSet Parms{};

	Parms.InputContext = InputContext;
	Parms.Action = Action;
	Parms.Key = std::move(Key);
	Parms.BlockingIssues = BlockingIssues;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.QueryMapKeyInContextSet
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UInputMappingContext*>&PrioritizedActiveContexts                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const class UInputMappingContext*       InputContext                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      Key                                                    (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FMappingQueryIssue>*      OutIssues                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// EMappingQueryIssue                      BlockingIssues                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMappingQueryResult                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EMappingQueryResult IEnhancedInputSubsystemInterface::QueryMapKeyInContextSet(const TArray<class UInputMappingContext*>& PrioritizedActiveContexts, const class UInputMappingContext* InputContext, const class UInputAction* Action, const struct FKey& Key, TArray<struct FMappingQueryIssue>* OutIssues, EMappingQueryIssue BlockingIssues)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "QueryMapKeyInContextSet");

	Params::EnhancedInputSubsystemInterface_QueryMapKeyInContextSet Parms{};

	Parms.PrioritizedActiveContexts = std::move(PrioritizedActiveContexts);
	Parms.InputContext = InputContext;
	Parms.Action = Action;
	Parms.Key = std::move(Key);
	Parms.BlockingIssues = BlockingIssues;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.RemoveMappingContext
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UInputMappingContext*       MappingContext                                         (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FModifyContextOptions&     Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::RemoveMappingContext(const class UInputMappingContext* MappingContext, const struct FModifyContextOptions& Options)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "RemoveMappingContext");

	Params::EnhancedInputSubsystemInterface_RemoveMappingContext Parms{};

	Parms.MappingContext = MappingContext;
	Parms.Options = std::move(Options);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.RemoveTagFromInputMode
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TagToRemove                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FModifyContextOptions&     Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::RemoveTagFromInputMode(const struct FGameplayTag& TagToRemove, const struct FModifyContextOptions& Options)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "RemoveTagFromInputMode");

	Params::EnhancedInputSubsystemInterface_RemoveTagFromInputMode Parms{};

	Parms.TagToRemove = std::move(TagToRemove);
	Parms.Options = std::move(Options);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.RemoveTagsFromInputMode
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     TagsToRemove                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FModifyContextOptions&     Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::RemoveTagsFromInputMode(const struct FGameplayTagContainer& TagsToRemove, const struct FModifyContextOptions& Options)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "RemoveTagsFromInputMode");

	Params::EnhancedInputSubsystemInterface_RemoveTagsFromInputMode Parms{};

	Parms.TagsToRemove = std::move(TagsToRemove);
	Parms.Options = std::move(Options);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.RequestRebuildControlMappings
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FModifyContextOptions&     Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// EInputMappingRebuildType                RebuildType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::RequestRebuildControlMappings(const struct FModifyContextOptions& Options, EInputMappingRebuildType RebuildType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "RequestRebuildControlMappings");

	Params::EnhancedInputSubsystemInterface_RequestRebuildControlMappings Parms{};

	Parms.Options = std::move(Options);
	Parms.RebuildType = RebuildType;

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.SetInputMode
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     NewMode                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FModifyContextOptions&     Options                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::SetInputMode(const struct FGameplayTagContainer& NewMode, const struct FModifyContextOptions& Options)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "SetInputMode");

	Params::EnhancedInputSubsystemInterface_SetInputMode Parms{};

	Parms.NewMode = std::move(NewMode);
	Parms.Options = std::move(Options);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.StartContinuousInputInjectionForAction
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputActionValue&         RawValue                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<class UInputModifier*>&    Modifiers                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class UInputTrigger*>&     Triggers                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::StartContinuousInputInjectionForAction(const class UInputAction* Action, const struct FInputActionValue& RawValue, const TArray<class UInputModifier*>& Modifiers, const TArray<class UInputTrigger*>& Triggers)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "StartContinuousInputInjectionForAction");

	Params::EnhancedInputSubsystemInterface_StartContinuousInputInjectionForAction Parms{};

	Parms.Action = Action;
	Parms.RawValue = std::move(RawValue);
	Parms.Modifiers = std::move(Modifiers);
	Parms.Triggers = std::move(Triggers);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.StartContinuousInputInjectionForPlayerMapping
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName                       MappingName                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputActionValue&         RawValue                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<class UInputModifier*>&    Modifiers                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class UInputTrigger*>&     Triggers                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::StartContinuousInputInjectionForPlayerMapping(const class FName MappingName, const struct FInputActionValue& RawValue, const TArray<class UInputModifier*>& Modifiers, const TArray<class UInputTrigger*>& Triggers)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "StartContinuousInputInjectionForPlayerMapping");

	Params::EnhancedInputSubsystemInterface_StartContinuousInputInjectionForPlayerMapping Parms{};

	Parms.MappingName = MappingName;
	Parms.RawValue = std::move(RawValue);
	Parms.Modifiers = std::move(Modifiers);
	Parms.Triggers = std::move(Triggers);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.StopContinuousInputInjectionForAction
// (RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::StopContinuousInputInjectionForAction(const class UInputAction* Action)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "StopContinuousInputInjectionForAction");

	Params::EnhancedInputSubsystemInterface_StopContinuousInputInjectionForAction Parms{};

	Parms.Action = Action;

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.StopContinuousInputInjectionForPlayerMapping
// (RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FName                       MappingName                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::StopContinuousInputInjectionForPlayerMapping(const class FName MappingName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "StopContinuousInputInjectionForPlayerMapping");

	Params::EnhancedInputSubsystemInterface_StopContinuousInputInjectionForPlayerMapping Parms{};

	Parms.MappingName = MappingName;

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.UpdateValueOfContinuousInputInjectionForAction
// (RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputActionValue&         RawValue                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::UpdateValueOfContinuousInputInjectionForAction(const class UInputAction* Action, const struct FInputActionValue& RawValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "UpdateValueOfContinuousInputInjectionForAction");

	Params::EnhancedInputSubsystemInterface_UpdateValueOfContinuousInputInjectionForAction Parms{};

	Parms.Action = Action;
	Parms.RawValue = std::move(RawValue);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.UpdateValueOfContinuousInputInjectionForPlayerMapping
// (RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FName                       MappingName                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputActionValue&         RawValue                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)

void IEnhancedInputSubsystemInterface::UpdateValueOfContinuousInputInjectionForPlayerMapping(const class FName MappingName, const struct FInputActionValue& RawValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "UpdateValueOfContinuousInputInjectionForPlayerMapping");

	Params::EnhancedInputSubsystemInterface_UpdateValueOfContinuousInputInjectionForPlayerMapping Parms{};

	Parms.MappingName = MappingName;
	Parms.RawValue = std::move(RawValue);

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

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

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.GetAllPlayerMappableActionKeyMappings
// (RequiredAPI, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FEnhancedActionKeyMapping>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<struct FEnhancedActionKeyMapping> IEnhancedInputSubsystemInterface::GetAllPlayerMappableActionKeyMappings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "GetAllPlayerMappableActionKeyMappings");

	Params::EnhancedInputSubsystemInterface_GetAllPlayerMappableActionKeyMappings Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.GetInputMode
// (RequiredAPI, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGameplayTagContainer            ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameplayTagContainer IEnhancedInputSubsystemInterface::GetInputMode() const
{
	static class UFunction* Func = nullptr;

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

	Params::EnhancedInputSubsystemInterface_GetInputMode Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.GetUserSettings
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEnhancedInputUserSettings*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEnhancedInputUserSettings* IEnhancedInputSubsystemInterface::GetUserSettings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "GetUserSettings");

	Params::EnhancedInputSubsystemInterface_GetUserSettings Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.HasMappingContext
// (RequiredAPI, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInputMappingContext*       MappingContext                                         (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutFoundPriority                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IEnhancedInputSubsystemInterface::HasMappingContext(const class UInputMappingContext* MappingContext, int32* OutFoundPriority) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "HasMappingContext");

	Params::EnhancedInputSubsystemInterface_HasMappingContext Parms{};

	Parms.MappingContext = MappingContext;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputSubsystemInterface.QueryKeysMappedToAction
// (RequiredAPI, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FKey>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FKey> IEnhancedInputSubsystemInterface::QueryKeysMappedToAction(const class UInputAction* Action) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EnhancedInputSubsystemInterface", "QueryKeysMappedToAction");

	Params::EnhancedInputSubsystemInterface_QueryKeysMappedToAction Parms{};

	Parms.Action = Action;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.EnhancedInputWorldSubsystem.AddActorInputComponent
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEnhancedInputWorldSubsystem::AddActorInputComponent(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputWorldSubsystem", "AddActorInputComponent");

	Params::EnhancedInputWorldSubsystem_AddActorInputComponent Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.EnhancedInputWorldSubsystem.RemoveActorInputComponent
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEnhancedInputWorldSubsystem::RemoveActorInputComponent(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnhancedInputWorldSubsystem", "RemoveActorInputComponent");

	Params::EnhancedInputWorldSubsystem_RemoveActorInputComponent Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.InputMappingContext.ShouldShowInputModeQuery
// (Final, RequiredAPI, Native, Static, Public)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInputMappingContext::ShouldShowInputModeQuery()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InputMappingContext", "ShouldShowInputModeQuery");

	Params::InputMappingContext_ShouldShowInputModeQuery Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.InputMappingContext.MapKey
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      ToKey                                                  (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FEnhancedActionKeyMapping        ReturnValue                                            (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FEnhancedActionKeyMapping UInputMappingContext::MapKey(const class UInputAction* Action, const struct FKey& ToKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InputMappingContext", "MapKey");

	Params::InputMappingContext_MapKey Parms{};

	Parms.Action = Action;
	Parms.ToKey = std::move(ToKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.InputMappingContext.UnmapAll
// (Final, RequiredAPI, Native, Public, BlueprintCallable)

void UInputMappingContext::UnmapAll()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InputMappingContext", "UnmapAll");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.InputMappingContext.UnmapAllKeysFromAction
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInputMappingContext::UnmapAllKeysFromAction(const class UInputAction* Action)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InputMappingContext", "UnmapAllKeysFromAction");

	Params::InputMappingContext_UnmapAllKeysFromAction Parms{};

	Parms.Action = Action;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.InputMappingContext.UnmapKey
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class UInputAction*               Action                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      Key                                                    (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInputMappingContext::UnmapKey(const class UInputAction* Action, const struct FKey& Key)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InputMappingContext", "UnmapKey");

	Params::InputMappingContext_UnmapKey Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.InputModifier.GetVisualizationColor
// (RequiredAPI, Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// const struct FInputActionValue&         SampleValue                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FInputActionValue&         FinalValue                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FLinearColor UInputModifier::GetVisualizationColor(const struct FInputActionValue& SampleValue, const struct FInputActionValue& FinalValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InputModifier", "GetVisualizationColor");

	Params::InputModifier_GetVisualizationColor Parms{};

	Parms.SampleValue = std::move(SampleValue);
	Parms.FinalValue = std::move(FinalValue);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.InputModifier.ModifyRaw
// (RequiredAPI, Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const class UEnhancedPlayerInput*       PlayerInput                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputActionValue&         CurrentValue                                           (Parm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FInputActionValue                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FInputActionValue UInputModifier::ModifyRaw(const class UEnhancedPlayerInput* PlayerInput, const struct FInputActionValue& CurrentValue, float DeltaTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InputModifier", "ModifyRaw");

	Params::InputModifier_ModifyRaw Parms{};

	Parms.PlayerInput = PlayerInput;
	Parms.CurrentValue = std::move(CurrentValue);
	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.InputTrigger.UpdateState
// (RequiredAPI, Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UEnhancedPlayerInput*       PlayerInput                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputActionValue&         ModifiedValue                                          (Parm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETriggerState                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ETriggerState UInputTrigger::UpdateState(const class UEnhancedPlayerInput* PlayerInput, const struct FInputActionValue& ModifiedValue, float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InputTrigger", "UpdateState");

	Params::InputTrigger_UpdateState Parms{};

	Parms.PlayerInput = PlayerInput;
	Parms.ModifiedValue = std::move(ModifiedValue);
	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.InputTrigger.GetTriggerType
// (RequiredAPI, Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// ETriggerType                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ETriggerType UInputTrigger::GetTriggerType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InputTrigger", "GetTriggerType");

	Params::InputTrigger_GetTriggerType Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.InputTrigger.IsActuated
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FInputActionValue&         ForValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInputTrigger::IsActuated(const struct FInputActionValue& ForValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InputTrigger", "IsActuated");

	Params::InputTrigger_IsActuated Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.PlayerMappableInputConfig.ResetToDefault
// (Final, Native, Public, BlueprintCallable)

void UPlayerMappableInputConfig::ResetToDefault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerMappableInputConfig", "ResetToDefault");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function EnhancedInput.PlayerMappableInputConfig.GetConfigName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class FName UPlayerMappableInputConfig::GetConfigName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerMappableInputConfig", "GetConfigName");

	Params::PlayerMappableInputConfig_GetConfigName Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.PlayerMappableInputConfig.GetDisplayName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FText                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const class FText UPlayerMappableInputConfig::GetDisplayName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerMappableInputConfig", "GetDisplayName");

	Params::PlayerMappableInputConfig_GetDisplayName Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.PlayerMappableInputConfig.GetKeysBoundToAction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInputAction*               InAction                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FEnhancedActionKeyMapping>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<struct FEnhancedActionKeyMapping> UPlayerMappableInputConfig::GetKeysBoundToAction(const class UInputAction* InAction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerMappableInputConfig", "GetKeysBoundToAction");

	Params::PlayerMappableInputConfig_GetKeysBoundToAction Parms{};

	Parms.InAction = InAction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.PlayerMappableInputConfig.GetMappingByName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       MappingName                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FEnhancedActionKeyMapping        ReturnValue                                            (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FEnhancedActionKeyMapping UPlayerMappableInputConfig::GetMappingByName(const class FName MappingName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerMappableInputConfig", "GetMappingByName");

	Params::PlayerMappableInputConfig_GetMappingByName Parms{};

	Parms.MappingName = MappingName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.PlayerMappableInputConfig.GetMappingContexts
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TMap<class UInputMappingContext*, int32>ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TMap<class UInputMappingContext*, int32> UPlayerMappableInputConfig::GetMappingContexts() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerMappableInputConfig", "GetMappingContexts");

	Params::PlayerMappableInputConfig_GetMappingContexts Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.PlayerMappableInputConfig.GetMetadata
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UPlayerMappableInputConfig::GetMetadata() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerMappableInputConfig", "GetMetadata");

	Params::PlayerMappableInputConfig_GetMetadata Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.PlayerMappableInputConfig.GetPlayerMappableKeys
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FEnhancedActionKeyMapping>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<struct FEnhancedActionKeyMapping> UPlayerMappableInputConfig::GetPlayerMappableKeys() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerMappableInputConfig", "GetPlayerMappableKeys");

	Params::PlayerMappableInputConfig_GetPlayerMappableKeys Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function EnhancedInput.PlayerMappableInputConfig.IsDeprecated
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const bool                              ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const bool UPlayerMappableInputConfig::IsDeprecated() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerMappableInputConfig", "IsDeprecated");

	Params::PlayerMappableInputConfig_IsDeprecated Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


SDK_NAMESPACE_END
